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
, deletion
;
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 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
955 PT
+ combined_after_bytes
,
956 PT_BYTE
+ combined_after_bytes
, 1);
958 adjust_markers_for_record_delete (PT
, PT_BYTE
,
959 PT
+ combined_after_bytes
,
960 PT_BYTE
+ combined_after_bytes
);
961 record_delete (PT
, deletion
);
964 if (combined_before_bytes
)
966 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
968 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
970 record_delete (PT
- 1, deletion
);
973 record_insert (PT
- !!combined_before_bytes
,
974 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
977 bcopy (string
, GPT_ADDR
, nbytes
);
980 /* When we have combining at the end of the insertion,
981 this is the character position before the combined character. */
988 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
990 if (combined_after_bytes
)
991 move_gap_both (GPT
+ combined_after_bytes
,
992 GPT_BYTE
+ combined_after_bytes
);
997 adjust_overlays_for_insert (PT
, nchars
);
998 adjust_markers_for_insert (PT
, PT_BYTE
,
999 PT
+ nchars
, PT_BYTE
+ nbytes
,
1000 combined_before_bytes
, combined_after_bytes
,
1003 #ifdef USE_TEXT_PROPERTIES
1004 if (BUF_INTERVALS (current_buffer
) != 0)
1005 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES. */
1006 offset_intervals (current_buffer
, PT
, nchars
);
1008 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
1009 Fset_text_properties (make_number (PT
), make_number (PT
+ nchars
),
1014 int pos
= PT
, pos_byte
= PT_BYTE
;
1016 adjust_point (nchars
+ combined_after_bytes
,
1017 nbytes
+ combined_after_bytes
);
1019 if (combined_after_bytes
)
1020 combine_bytes (pos
+ nchars
, pos_byte
+ nbytes
, combined_after_bytes
);
1022 if (combined_before_bytes
)
1023 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1027 /* Insert the part of the text of STRING, a Lisp object assumed to be
1028 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
1029 starting at position POS / POS_BYTE. If the text of STRING has properties,
1030 copy them into the buffer.
1032 It does not work to use `insert' for this, because a GC could happen
1033 before we bcopy the stuff into the buffer, and relocate the string
1034 without insert noticing. */
1037 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
1039 register int pos
, pos_byte
, length
, length_byte
;
1045 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1047 signal_after_change (opoint
, 0, PT
- opoint
);
1051 /* Like `insert_from_string' except that all markers pointing
1052 at the place where the insertion happens are adjusted to point after it. */
1055 insert_from_string_before_markers (string
, pos
, pos_byte
,
1056 length
, length_byte
, inherit
)
1058 register int pos
, pos_byte
, length
, length_byte
;
1064 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1066 signal_after_change (opoint
, 0, PT
- opoint
);
1070 /* Subroutine of the insertion functions above. */
1073 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1074 inherit
, before_markers
)
1076 register int pos
, pos_byte
, nchars
, nbytes
;
1077 int inherit
, before_markers
;
1079 register Lisp_Object temp
;
1080 struct gcpro gcpro1
;
1081 int outgoing_nbytes
= nbytes
;
1082 int combined_before_bytes
, combined_after_bytes
;
1083 int adjusted_nchars
;
1085 Lisp_Object deletion
;
1087 /* Make OUTGOING_NBYTES describe the text
1088 as it will be inserted in this buffer. */
1090 if (NILP (current_buffer
->enable_multibyte_characters
))
1091 outgoing_nbytes
= nchars
;
1092 else if (nchars
== nbytes
)
1094 = count_size_as_multibyte (&XSTRING (string
)->data
[pos_byte
],
1097 /* Make sure point-max won't overflow after this insertion. */
1098 XSETINT (temp
, outgoing_nbytes
+ Z
);
1099 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1100 error ("Maximum buffer size exceeded");
1103 prepare_to_modify_buffer (PT
, PT
, NULL
);
1106 move_gap_both (PT
, PT_BYTE
);
1107 if (GAP_SIZE
< nbytes
)
1108 make_gap (outgoing_nbytes
- GAP_SIZE
);
1111 /* Copy the string text into the buffer, perhaps converting
1112 between single-byte and multibyte. */
1113 copy_text (XSTRING (string
)->data
+ pos_byte
, GPT_ADDR
, nbytes
,
1114 /* If these are equal, it is a single-byte string.
1115 Its chars are either ASCII, in which case copy_text
1116 won't change it, or single-byte non-ASCII chars,
1117 that need to be changed. */
1119 ! NILP (current_buffer
->enable_multibyte_characters
));
1121 /* We have copied text into the gap, but we have not altered
1122 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1123 to these functions and get the same results as we would
1124 have got earlier on. Meanwhile, PT_ADDR does point to
1125 the text that has been stored by copy_text. */
1127 combined_before_bytes
1128 = count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1129 combined_after_bytes
1130 = count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1132 /* Record deletion of the surrounding text that combines with
1133 the insertion. This, together with recording the insertion,
1134 will add up to the right stuff in the undo list.
1136 But there is no need to actually delete the combining bytes
1137 from the buffer and reinsert them. */
1139 if (combined_after_bytes
)
1141 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1142 PT
+ combined_after_bytes
,
1143 PT_BYTE
+ combined_after_bytes
, 1);
1145 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1146 PT
+ combined_after_bytes
,
1147 PT_BYTE
+ combined_after_bytes
);
1148 record_delete (PT
, deletion
);
1151 if (combined_before_bytes
)
1153 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1155 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1157 record_delete (PT
- 1, deletion
);
1160 record_insert (PT
- !!combined_before_bytes
,
1161 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1164 GAP_SIZE
-= outgoing_nbytes
;
1168 GPT_BYTE
+= outgoing_nbytes
;
1169 ZV_BYTE
+= outgoing_nbytes
;
1170 Z_BYTE
+= outgoing_nbytes
;
1171 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1173 if (combined_after_bytes
)
1174 move_gap_both (GPT
+ combined_after_bytes
,
1175 GPT_BYTE
+ combined_after_bytes
);
1180 adjust_overlays_for_insert (PT
, nchars
);
1181 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1182 PT_BYTE
+ outgoing_nbytes
,
1183 combined_before_bytes
, combined_after_bytes
,
1186 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
1187 offset_intervals (current_buffer
, PT
, nchars
);
1189 intervals
= XSTRING (string
)->intervals
;
1190 /* Get the intervals for the part of the string we are inserting--
1191 not including the combined-before bytes. */
1192 if (nbytes
< XSTRING (string
)->size_byte
)
1193 intervals
= copy_intervals (intervals
, pos
, nchars
);
1195 /* Insert those intervals. */
1196 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1197 current_buffer
, inherit
);
1200 int pos
= PT
, pos_byte
= PT_BYTE
;
1202 adjust_point (nchars
+ combined_after_bytes
,
1203 outgoing_nbytes
+ combined_after_bytes
);
1205 if (combined_after_bytes
)
1206 combine_bytes (pos
+ nchars
, pos_byte
+ outgoing_nbytes
,
1207 combined_after_bytes
);
1209 if (combined_before_bytes
)
1210 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1214 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1215 current buffer. If the text in BUF has properties, they are absorbed
1216 into the current buffer.
1218 It does not work to use `insert' for this, because a malloc could happen
1219 and relocate BUF's text before the bcopy happens. */
1222 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1224 int charpos
, nchars
;
1231 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1232 signal_after_change (opoint
, 0, PT
- opoint
);
1237 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1242 register Lisp_Object temp
, deletion
;
1244 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1245 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1246 int incoming_nbytes
= to_byte
- from_byte
;
1247 int outgoing_nbytes
= incoming_nbytes
;
1248 int combined_before_bytes
, combined_after_bytes
;
1249 int adjusted_nchars
;
1252 /* Make OUTGOING_NBYTES describe the text
1253 as it will be inserted in this buffer. */
1255 if (NILP (current_buffer
->enable_multibyte_characters
))
1256 outgoing_nbytes
= nchars
;
1257 else if (NILP (buf
->enable_multibyte_characters
))
1259 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1262 /* Make sure point-max won't overflow after this insertion. */
1263 XSETINT (temp
, outgoing_nbytes
+ Z
);
1264 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1265 error ("Maximum buffer size exceeded");
1267 prepare_to_modify_buffer (PT
, PT
, NULL
);
1270 move_gap_both (PT
, PT_BYTE
);
1271 if (GAP_SIZE
< outgoing_nbytes
)
1272 make_gap (outgoing_nbytes
- GAP_SIZE
);
1274 if (from
< BUF_GPT (buf
))
1276 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1277 if (chunk
> incoming_nbytes
)
1278 chunk
= incoming_nbytes
;
1279 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1281 ! NILP (buf
->enable_multibyte_characters
),
1282 ! NILP (current_buffer
->enable_multibyte_characters
));
1286 if (chunk
< incoming_nbytes
)
1287 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1288 GPT_ADDR
+ chunk
, incoming_nbytes
- chunk
,
1289 ! NILP (buf
->enable_multibyte_characters
),
1290 ! NILP (current_buffer
->enable_multibyte_characters
));
1292 /* We have copied text into the gap, but we have not altered
1293 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1294 to these functions and get the same results as we would
1295 have got earlier on. Meanwhile, GPT_ADDR does point to
1296 the text that has been stored by copy_text. */
1297 combined_before_bytes
1298 = count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
);
1299 combined_after_bytes
1300 = count_combining_after (GPT_ADDR
, outgoing_nbytes
,
1303 /* Record deletion of the surrounding text that combines with
1304 the insertion. This, together with recording the insertion,
1305 will add up to the right stuff in the undo list.
1307 But there is no need to actually delete the combining bytes
1308 from the buffer and reinsert them. */
1310 if (combined_after_bytes
)
1312 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1313 PT
+ combined_after_bytes
,
1314 PT_BYTE
+ combined_after_bytes
, 1);
1316 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1317 PT
+ combined_after_bytes
,
1318 PT_BYTE
+ combined_after_bytes
);
1319 record_delete (PT
, deletion
);
1322 if (combined_before_bytes
)
1324 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1326 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1328 record_delete (PT
- 1, deletion
);
1331 record_insert (PT
- !!combined_before_bytes
,
1332 nchars
- combined_before_bytes
+ !!combined_before_bytes
);
1335 GAP_SIZE
-= outgoing_nbytes
;
1339 GPT_BYTE
+= outgoing_nbytes
;
1340 ZV_BYTE
+= outgoing_nbytes
;
1341 Z_BYTE
+= outgoing_nbytes
;
1342 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1344 if (combined_after_bytes
)
1345 move_gap_both (GPT
+ combined_after_bytes
,
1346 GPT_BYTE
+ combined_after_bytes
);
1351 adjust_overlays_for_insert (PT
, nchars
);
1352 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1353 PT_BYTE
+ outgoing_nbytes
,
1354 combined_before_bytes
, combined_after_bytes
, 0);
1356 #ifdef USE_TEXT_PROPERTIES
1357 if (BUF_INTERVALS (current_buffer
) != 0)
1358 offset_intervals (current_buffer
, PT
, nchars
);
1361 /* Get the intervals for the part of the string we are inserting--
1362 not including the combined-before bytes. */
1363 intervals
= BUF_INTERVALS (buf
);
1364 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1365 intervals
= copy_intervals (intervals
, from
, nchars
);
1367 /* Insert those intervals. */
1368 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1371 int pos
= PT
, pos_byte
= PT_BYTE
;
1373 adjust_point (nchars
+ combined_after_bytes
,
1374 outgoing_nbytes
+ combined_after_bytes
);
1376 if (combined_after_bytes
)
1377 combine_bytes (pos
+ nchars
, pos_byte
+ outgoing_nbytes
,
1378 combined_after_bytes
);
1380 if (combined_before_bytes
)
1381 combine_bytes (pos
, pos_byte
, combined_before_bytes
);
1385 /* This function should be called after moving gap to FROM and before
1386 altering text between FROM and TO. This adjusts various position
1387 keepers and markers as if the text is deleted. Don't forget to
1388 call adjust_after_replace after you actually alter the text. */
1391 adjust_before_replace (from
, from_byte
, to
, to_byte
)
1392 int from
, from_byte
, to
, to_byte
;
1394 Lisp_Object deletion
;
1395 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1397 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1398 record_delete (from
, deletion
);
1399 adjust_overlays_for_delete (from
, to
- from
);
1402 /* This function should be called after altering the text between FROM
1403 and TO to a new text of LEN chars (LEN_BYTE bytes), but before
1404 making the text a buffer contents. It exists just after GPT_ADDR. */
1407 adjust_after_replace (from
, from_byte
, to
, to_byte
, len
, len_byte
, replace
)
1408 int from
, from_byte
, to
, to_byte
, len
, len_byte
, replace
;
1410 int combined_before_bytes
1411 = count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
);
1412 int combined_after_bytes
1413 = count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
);
1414 Lisp_Object deletion
;
1416 if (combined_after_bytes
)
1418 deletion
= make_buffer_string_both (from
, from_byte
,
1419 from
+ combined_after_bytes
,
1420 from_byte
+ combined_after_bytes
, 1);
1422 adjust_markers_for_record_delete (from
, from_byte
,
1423 from
+ combined_after_bytes
,
1424 from_byte
+ combined_after_bytes
);
1425 record_delete (from
, deletion
);
1428 if (combined_before_bytes
)
1430 deletion
= make_buffer_string_both (from
- 1, CHAR_TO_BYTE (from
- 1),
1431 from
, from_byte
, 1);
1432 adjust_markers_for_record_delete (from
- 1, CHAR_TO_BYTE (from
- 1),
1434 record_delete (from
- 1, deletion
);
1437 /* Update various buffer positions for the new text. */
1438 GAP_SIZE
-= len_byte
;
1440 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1441 GPT
+= len
; GPT_BYTE
+= len_byte
;
1442 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1444 if (combined_after_bytes
)
1445 move_gap_both (GPT
+ combined_after_bytes
,
1446 GPT_BYTE
+ combined_after_bytes
);
1448 record_insert (from
- !!combined_before_bytes
,
1449 len
- combined_before_bytes
+ !!combined_before_bytes
);
1450 adjust_overlays_for_insert (from
, len
);
1451 adjust_markers_for_insert (from
, from_byte
,
1452 from
+ len
, from_byte
+ len_byte
,
1453 combined_before_bytes
, combined_after_bytes
, 0);
1454 #ifdef USE_TEXT_PROPERTIES
1455 if (BUF_INTERVALS (current_buffer
) != 0)
1456 /* REPLACE zero means that we have not yet adjusted the interval
1457 tree for the text between FROM and TO, thus, we must treat the
1458 new text as a newly inserted text, not as a replacement of
1460 offset_intervals (current_buffer
, from
, len
- (replace
? to
- from
: 0));
1464 int pos
= PT
, pos_byte
= PT_BYTE
;
1467 adjust_point (len
- (to
- from
) + combined_after_bytes
,
1468 len_byte
- (to_byte
- from_byte
) + combined_after_bytes
);
1469 else if (from
== PT
&& combined_before_bytes
)
1470 adjust_point (0, combined_before_bytes
);
1472 if (combined_after_bytes
)
1473 combine_bytes (from
+ len
, from_byte
+ len_byte
, combined_after_bytes
);
1475 if (combined_before_bytes
)
1476 combine_bytes (from
, from_byte
, combined_before_bytes
);
1480 evaporate_overlays (from
);
1484 /* Replace the text from character positions FROM to TO with NEW,
1485 If PREPARE is nonzero, call prepare_to_modify_buffer.
1486 If INHERIT, the newly inserted text should inherit text properties
1487 from the surrounding non-deleted text. */
1489 /* Note that this does not yet handle markers quite right.
1490 Also it needs to record a single undo-entry that does a replacement
1491 rather than a separate delete and insert.
1492 That way, undo will also handle markers properly. */
1495 replace_range (from
, to
, new, prepare
, inherit
)
1497 int from
, to
, prepare
, inherit
;
1499 int inschars
= XSTRING (new)->size
;
1500 int insbytes
= XSTRING (new)->size_byte
;
1501 int from_byte
, to_byte
;
1502 int nbytes_del
, nchars_del
;
1503 register Lisp_Object temp
;
1504 struct gcpro gcpro1
;
1505 int combined_before_bytes
, combined_after_bytes
;
1506 int adjusted_inschars
;
1508 int outgoing_insbytes
= insbytes
;
1509 Lisp_Object deletion
;
1515 int range_length
= to
- from
;
1516 prepare_to_modify_buffer (from
, to
, &from
);
1517 to
= from
+ range_length
;
1522 /* Make args be valid */
1528 from_byte
= CHAR_TO_BYTE (from
);
1529 to_byte
= CHAR_TO_BYTE (to
);
1531 nchars_del
= to
- from
;
1532 nbytes_del
= to_byte
- from_byte
;
1534 if (nbytes_del
<= 0 && insbytes
== 0)
1537 /* Make OUTGOING_INSBYTES describe the text
1538 as it will be inserted in this buffer. */
1540 if (NILP (current_buffer
->enable_multibyte_characters
))
1541 outgoing_insbytes
= inschars
;
1542 else if (inschars
== insbytes
)
1544 = count_size_as_multibyte (XSTRING (new)->data
, insbytes
);
1546 /* Make sure point-max won't overflow after this insertion. */
1547 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1548 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1549 error ("Maximum buffer size exceeded");
1553 /* Make sure the gap is somewhere in or next to what we are deleting. */
1555 gap_right (from
, from_byte
);
1557 gap_left (to
, to_byte
, 0);
1559 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1561 /* Relocate all markers pointing into the new, larger gap
1562 to point at the end of the text before the gap.
1563 Do this before recording the deletion,
1564 so that undo handles this after reinserting the text. */
1565 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1567 record_delete (from
, deletion
);
1569 GAP_SIZE
+= nbytes_del
;
1572 ZV_BYTE
-= nbytes_del
;
1573 Z_BYTE
-= nbytes_del
;
1575 GPT_BYTE
= from_byte
;
1576 *(GPT_ADDR
) = 0; /* Put an anchor. */
1581 if (GPT
- BEG
< beg_unchanged
)
1582 beg_unchanged
= GPT
- BEG
;
1583 if (Z
- GPT
< end_unchanged
)
1584 end_unchanged
= Z
- GPT
;
1586 if (GAP_SIZE
< insbytes
)
1587 make_gap (insbytes
- GAP_SIZE
);
1589 /* Copy the string text into the buffer, perhaps converting
1590 between single-byte and multibyte. */
1591 copy_text (XSTRING (new)->data
, GPT_ADDR
, insbytes
,
1592 /* If these are equal, it is a single-byte string.
1593 Its chars are either ASCII, in which case copy_text
1594 won't change it, or single-byte non-ASCII chars,
1595 that need to be changed. */
1596 inschars
!= insbytes
,
1597 ! NILP (current_buffer
->enable_multibyte_characters
));
1599 /* We have copied text into the gap, but we have not altered
1600 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1601 to these functions and get the same results as we would
1602 have got earlier on. Meanwhile, GPT_ADDR does point to
1603 the text that has been stored by copy_text. */
1605 combined_before_bytes
1606 = count_combining_before (GPT_ADDR
, outgoing_insbytes
, PT
, PT_BYTE
);
1607 combined_after_bytes
1608 = count_combining_after (GPT_ADDR
, outgoing_insbytes
, PT
, PT_BYTE
);
1610 /* Record deletion of the surrounding text that combines with
1611 the insertion. This, together with recording the insertion,
1612 will add up to the right stuff in the undo list.
1614 But there is no need to actually delete the combining bytes
1615 from the buffer and reinsert them. */
1617 if (combined_after_bytes
)
1619 deletion
= make_buffer_string_both (PT
, PT_BYTE
,
1620 PT
+ combined_after_bytes
,
1621 PT_BYTE
+ combined_after_bytes
, 1);
1623 adjust_markers_for_record_delete (PT
, PT_BYTE
,
1624 PT
+ combined_after_bytes
,
1625 PT_BYTE
+ combined_after_bytes
);
1626 record_delete (PT
, deletion
);
1629 if (combined_before_bytes
)
1631 deletion
= make_buffer_string_both (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1633 adjust_markers_for_record_delete (PT
- 1, CHAR_TO_BYTE (PT
- 1),
1635 record_delete (PT
- 1, deletion
);
1638 record_insert (PT
- !!combined_before_bytes
,
1639 inschars
- combined_before_bytes
+ !!combined_before_bytes
);
1641 GAP_SIZE
-= outgoing_insbytes
;
1645 GPT_BYTE
+= outgoing_insbytes
;
1646 ZV_BYTE
+= outgoing_insbytes
;
1647 Z_BYTE
+= outgoing_insbytes
;
1648 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1650 if (combined_after_bytes
)
1651 move_gap_both (GPT
+ combined_after_bytes
,
1652 GPT_BYTE
+ combined_after_bytes
);
1657 /* Adjust the overlay center as needed. This must be done after
1658 adjusting the markers that bound the overlays. */
1659 adjust_overlays_for_delete (from
, nchars_del
);
1660 adjust_overlays_for_insert (from
, inschars
);
1661 adjust_markers_for_insert (from
, from_byte
,
1662 from
+ inschars
, from_byte
+ outgoing_insbytes
,
1663 combined_before_bytes
, combined_after_bytes
, 0);
1665 #ifdef USE_TEXT_PROPERTIES
1666 offset_intervals (current_buffer
, PT
, inschars
- nchars_del
);
1668 /* Get the intervals for the part of the string we are inserting--
1669 not including the combined-before bytes. */
1670 intervals
= XSTRING (new)->intervals
;
1671 /* Insert those intervals. */
1672 graft_intervals_into_buffer (intervals
, from
, inschars
,
1673 current_buffer
, inherit
);
1676 /* Relocate point as if it were a marker. */
1678 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)
1679 + combined_after_bytes
),
1680 (from_byte
+ outgoing_insbytes
1681 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)
1682 + combined_after_bytes
));
1684 if (combined_after_bytes
)
1685 combine_bytes (from
+ inschars
, from_byte
+ outgoing_insbytes
,
1686 combined_after_bytes
);
1688 if (combined_before_bytes
)
1689 combine_bytes (from
, from_byte
, combined_before_bytes
);
1691 if (outgoing_insbytes
== 0)
1692 evaporate_overlays (from
);
1697 signal_after_change (from
, nchars_del
, PT
- from
);
1700 /* Delete characters in current buffer
1701 from FROM up to (but not including) TO.
1702 If TO comes before FROM, we delete nothing. */
1705 del_range (from
, to
)
1706 register int from
, to
;
1708 del_range_1 (from
, to
, 1);
1711 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer. */
1714 del_range_1 (from
, to
, prepare
)
1715 int from
, to
, prepare
;
1717 int from_byte
, to_byte
;
1719 /* Make args be valid */
1730 int range_length
= to
- from
;
1731 prepare_to_modify_buffer (from
, to
, &from
);
1732 to
= from
+ range_length
;
1735 from_byte
= CHAR_TO_BYTE (from
);
1736 to_byte
= CHAR_TO_BYTE (to
);
1738 del_range_2 (from
, from_byte
, to
, to_byte
);
1741 /* Like del_range_1 but args are byte positions, not char positions. */
1744 del_range_byte (from_byte
, to_byte
, prepare
)
1745 int from_byte
, to_byte
, prepare
;
1749 /* Make args be valid */
1750 if (from_byte
< BEGV_BYTE
)
1751 from_byte
= BEGV_BYTE
;
1752 if (to_byte
> ZV_BYTE
)
1755 if (to_byte
<= from_byte
)
1758 from
= BYTE_TO_CHAR (from_byte
);
1759 to
= BYTE_TO_CHAR (to_byte
);
1763 int old_from
= from
, old_to
= Z
- to
;
1764 int range_length
= to
- from
;
1765 prepare_to_modify_buffer (from
, to
, &from
);
1766 to
= from
+ range_length
;
1768 if (old_from
!= from
)
1769 from_byte
= CHAR_TO_BYTE (from
);
1770 if (old_to
== Z
- to
)
1771 to_byte
= CHAR_TO_BYTE (to
);
1774 del_range_2 (from
, from_byte
, to
, to_byte
);
1777 /* Like del_range_1, but positions are specified both as charpos
1781 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1782 int from
, from_byte
, to
, to_byte
, prepare
;
1784 /* Make args be valid */
1785 if (from_byte
< BEGV_BYTE
)
1786 from_byte
= BEGV_BYTE
;
1787 if (to_byte
> ZV_BYTE
)
1790 if (to_byte
<= from_byte
)
1800 int old_from
= from
, old_to
= Z
- to
;
1801 int range_length
= to
- from
;
1802 prepare_to_modify_buffer (from
, to
, &from
);
1803 to
= from
+ range_length
;
1805 if (old_from
!= from
)
1806 from_byte
= CHAR_TO_BYTE (from
);
1807 if (old_to
== Z
- to
)
1808 to_byte
= CHAR_TO_BYTE (to
);
1811 del_range_2 (from
, from_byte
, to
, to_byte
);
1814 /* Delete a range of text, specified both as character positions
1815 and byte positions. FROM and TO are character positions,
1816 while FROM_BYTE and TO_BYTE are byte positions. */
1819 del_range_2 (from
, from_byte
, to
, to_byte
)
1820 int from
, from_byte
, to
, to_byte
;
1822 register int nbytes_del
, nchars_del
;
1823 int combined_after_bytes
;
1824 Lisp_Object deletion
;
1827 nchars_del
= to
- from
;
1828 nbytes_del
= to_byte
- from_byte
;
1830 /* Make sure the gap is somewhere in or next to what we are deleting. */
1832 gap_right (from
, from_byte
);
1834 gap_left (to
, to_byte
, 0);
1836 combined_after_bytes
1837 = count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1838 ZV_BYTE
- to_byte
, from
, from_byte
);
1839 if (combined_after_bytes
)
1841 from_byte_1
= from_byte
;
1842 DEC_POS (from_byte_1
);
1845 from_byte_1
= from_byte
;
1848 = make_buffer_string_both (from
- !!combined_after_bytes
,
1850 to
+ combined_after_bytes
,
1851 to_byte
+ combined_after_bytes
, 1);
1853 /* Relocate all markers pointing into the new, larger gap
1854 to point at the end of the text before the gap.
1855 Do this before recording the deletion,
1856 so that undo handles this after reinserting the text. */
1857 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1858 if (combined_after_bytes
)
1860 /* Adjust markers for the phony deletion
1861 that we are about to call record_undo for. */
1863 /* Here we delete the markers that formerly
1864 pointed at TO ... TO + COMBINED_AFTER_BYTES.
1865 But because of the call to adjust_markers_for_delete, above,
1866 they now point at FROM ... FROM + COMBINED_AFTER_BYTES. */
1867 adjust_markers_for_record_delete (from
, from_byte
,
1868 from
+ combined_after_bytes
,
1869 from_byte
+ combined_after_bytes
);
1871 adjust_markers_for_record_delete (from
- 1, from_byte_1
,
1874 record_delete (from
- !!combined_after_bytes
, deletion
);
1876 if (combined_after_bytes
)
1877 /* COMBINED_AFTER_BYTES nonzero means that the above record_delete
1878 moved the gap by calling Fbuffer_substring. We must move the
1879 gap again to a proper place. */
1880 move_gap_both (from
, from_byte
);
1883 /* Relocate point as if it were a marker. */
1885 adjust_point (from
- (PT
< to
? PT
: to
),
1886 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1888 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
1889 offset_intervals (current_buffer
, from
, - nchars_del
);
1891 /* Adjust the overlay center as needed. This must be done after
1892 adjusting the markers that bound the overlays. */
1893 adjust_overlays_for_delete (from
, nchars_del
);
1895 GAP_SIZE
+= nbytes_del
;
1896 ZV_BYTE
-= nbytes_del
;
1897 Z_BYTE
-= nbytes_del
;
1901 GPT_BYTE
= from_byte
;
1903 if (combined_after_bytes
)
1904 move_gap_both (GPT
+ combined_after_bytes
,
1905 GPT_BYTE
+ combined_after_bytes
);
1907 *(GPT_ADDR
) = 0; /* Put an anchor. */
1912 if (GPT
- BEG
< beg_unchanged
)
1913 beg_unchanged
= GPT
- BEG
;
1914 if (Z
- GPT
< end_unchanged
)
1915 end_unchanged
= Z
- GPT
;
1917 if (combined_after_bytes
)
1919 combine_bytes (from
, from_byte
, combined_after_bytes
);
1921 record_insert (GPT
- 1, 1);
1924 evaporate_overlays (from
);
1925 signal_after_change (from
, nchars_del
, 0);
1928 /* Call this if you're about to change the region of BUFFER from
1929 character positions START to END. This checks the read-only
1930 properties of the region, calls the necessary modification hooks,
1931 and warns the next redisplay that it should pay attention to that
1935 modify_region (buffer
, start
, end
)
1936 struct buffer
*buffer
;
1939 struct buffer
*old_buffer
= current_buffer
;
1941 if (buffer
!= old_buffer
)
1942 set_buffer_internal (buffer
);
1944 prepare_to_modify_buffer (start
, end
, NULL
);
1946 if (start
- 1 < beg_unchanged
1947 || (unchanged_modified
== MODIFF
1948 && overlay_unchanged_modified
== OVERLAY_MODIFF
))
1949 beg_unchanged
= start
- 1;
1950 if (Z
- end
< end_unchanged
1951 || (unchanged_modified
== MODIFF
1952 && overlay_unchanged_modified
== OVERLAY_MODIFF
))
1953 end_unchanged
= Z
- end
;
1955 if (MODIFF
<= SAVE_MODIFF
)
1956 record_first_change ();
1959 buffer
->point_before_scroll
= Qnil
;
1961 if (buffer
!= old_buffer
)
1962 set_buffer_internal (old_buffer
);
1965 /* Check that it is okay to modify the buffer between START and END,
1966 which are char positions.
1968 Run the before-change-function, if any. If intervals are in use,
1969 verify that the text to be modified is not read-only, and call
1970 any modification properties the text may have.
1972 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1973 by holding its value temporarily in a marker. */
1976 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
1980 if (!NILP (current_buffer
->read_only
))
1981 Fbarf_if_buffer_read_only ();
1983 /* Only defined if Emacs is compiled with USE_TEXT_PROPERTIES */
1984 if (BUF_INTERVALS (current_buffer
) != 0)
1988 Lisp_Object preserve_marker
;
1989 struct gcpro gcpro1
;
1990 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
1991 GCPRO1 (preserve_marker
);
1992 verify_interval_modification (current_buffer
, start
, end
);
1993 *preserve_ptr
= marker_position (preserve_marker
);
1994 unchain_marker (preserve_marker
);
1998 verify_interval_modification (current_buffer
, start
, end
);
2001 #ifdef CLASH_DETECTION
2002 if (!NILP (current_buffer
->file_truename
)
2003 /* Make binding buffer-file-name to nil effective. */
2004 && !NILP (current_buffer
->filename
)
2005 && SAVE_MODIFF
>= MODIFF
)
2006 lock_file (current_buffer
->file_truename
);
2008 /* At least warn if this file has changed on disk since it was visited. */
2009 if (!NILP (current_buffer
->filename
)
2010 && SAVE_MODIFF
>= MODIFF
2011 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
2012 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
2013 call1 (intern ("ask-user-about-supersession-threat"),
2014 current_buffer
->filename
);
2015 #endif /* not CLASH_DETECTION */
2017 signal_before_change (start
, end
, preserve_ptr
);
2019 if (current_buffer
->newline_cache
)
2020 invalidate_region_cache (current_buffer
,
2021 current_buffer
->newline_cache
,
2022 start
- BEG
, Z
- end
);
2023 if (current_buffer
->width_run_cache
)
2024 invalidate_region_cache (current_buffer
,
2025 current_buffer
->width_run_cache
,
2026 start
- BEG
, Z
- end
);
2028 Vdeactivate_mark
= Qt
;
2031 /* These macros work with an argument named `preserve_ptr'
2032 and a local variable named `preserve_marker'. */
2034 #define PRESERVE_VALUE \
2035 if (preserve_ptr && NILP (preserve_marker)) \
2036 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
2038 #define RESTORE_VALUE \
2039 if (! NILP (preserve_marker)) \
2041 *preserve_ptr = marker_position (preserve_marker); \
2042 unchain_marker (preserve_marker); \
2045 #define PRESERVE_START_END \
2046 if (NILP (start_marker)) \
2047 start_marker = Fcopy_marker (start, Qnil); \
2048 if (NILP (end_marker)) \
2049 end_marker = Fcopy_marker (end, Qnil);
2051 #define FETCH_START \
2052 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
2055 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
2057 /* Signal a change to the buffer immediately before it happens.
2058 START_INT and END_INT are the bounds of the text to be changed.
2060 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
2061 by holding its value temporarily in a marker. */
2064 signal_before_change (start_int
, end_int
, preserve_ptr
)
2065 int start_int
, end_int
;
2068 Lisp_Object start
, end
;
2069 Lisp_Object start_marker
, end_marker
;
2070 Lisp_Object preserve_marker
;
2071 struct gcpro gcpro1
, gcpro2
, gcpro3
;
2073 start
= make_number (start_int
);
2074 end
= make_number (end_int
);
2075 preserve_marker
= Qnil
;
2076 start_marker
= Qnil
;
2078 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
2080 /* If buffer is unmodified, run a special hook for that case. */
2081 if (SAVE_MODIFF
>= MODIFF
2082 && !NILP (Vfirst_change_hook
)
2083 && !NILP (Vrun_hooks
))
2087 call1 (Vrun_hooks
, Qfirst_change_hook
);
2090 /* Run the before-change-function if any.
2091 We don't bother "binding" this variable to nil
2092 because it is obsolete anyway and new code should not use it. */
2093 if (!NILP (Vbefore_change_function
))
2097 call2 (Vbefore_change_function
, FETCH_START
, FETCH_END
);
2100 /* Now run the before-change-functions if any. */
2101 if (!NILP (Vbefore_change_functions
))
2103 Lisp_Object args
[3];
2104 Lisp_Object before_change_functions
;
2105 Lisp_Object after_change_functions
;
2106 struct gcpro gcpro1
, gcpro2
;
2111 /* "Bind" before-change-functions and after-change-functions
2112 to nil--but in a way that errors don't know about.
2113 That way, if there's an error in them, they will stay nil. */
2114 before_change_functions
= Vbefore_change_functions
;
2115 after_change_functions
= Vafter_change_functions
;
2116 Vbefore_change_functions
= Qnil
;
2117 Vafter_change_functions
= Qnil
;
2118 GCPRO2 (before_change_functions
, after_change_functions
);
2120 /* Actually run the hook functions. */
2121 args
[0] = Qbefore_change_functions
;
2122 args
[1] = FETCH_START
;
2123 args
[2] = FETCH_END
;
2124 run_hook_list_with_args (before_change_functions
, 3, args
);
2126 /* "Unbind" the variables we "bound" to nil. */
2127 Vbefore_change_functions
= before_change_functions
;
2128 Vafter_change_functions
= after_change_functions
;
2132 if (!NILP (current_buffer
->overlays_before
)
2133 || !NILP (current_buffer
->overlays_after
))
2136 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
2137 FETCH_START
, FETCH_END
, Qnil
);
2140 if (! NILP (start_marker
))
2141 free_marker (start_marker
);
2142 if (! NILP (end_marker
))
2143 free_marker (end_marker
);
2148 /* Signal a change immediately after it happens.
2149 CHARPOS is the character position of the start of the changed text.
2150 LENDEL is the number of characters of the text before the change.
2151 (Not the whole buffer; just the part that was changed.)
2152 LENINS is the number of characters in that part of the text
2153 after the change. */
2156 signal_after_change (charpos
, lendel
, lenins
)
2157 int charpos
, lendel
, lenins
;
2159 /* If we are deferring calls to the after-change functions
2160 and there are no before-change functions,
2161 just record the args that we were going to use. */
2162 if (! NILP (Vcombine_after_change_calls
)
2163 && NILP (Vbefore_change_function
) && NILP (Vbefore_change_functions
)
2164 && NILP (current_buffer
->overlays_before
)
2165 && NILP (current_buffer
->overlays_after
))
2169 if (!NILP (combine_after_change_list
)
2170 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
2171 Fcombine_after_change_execute ();
2173 elt
= Fcons (make_number (charpos
- BEG
),
2174 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
2175 Fcons (make_number (lenins
- lendel
), Qnil
)));
2176 combine_after_change_list
2177 = Fcons (elt
, combine_after_change_list
);
2178 combine_after_change_buffer
= Fcurrent_buffer ();
2183 if (!NILP (combine_after_change_list
))
2184 Fcombine_after_change_execute ();
2186 /* Run the after-change-function if any.
2187 We don't bother "binding" this variable to nil
2188 because it is obsolete anyway and new code should not use it. */
2189 if (!NILP (Vafter_change_function
))
2190 call3 (Vafter_change_function
,
2191 make_number (charpos
), make_number (charpos
+ lenins
),
2192 make_number (lendel
));
2194 if (!NILP (Vafter_change_functions
))
2196 Lisp_Object args
[4];
2197 Lisp_Object before_change_functions
;
2198 Lisp_Object after_change_functions
;
2199 struct gcpro gcpro1
, gcpro2
;
2201 /* "Bind" before-change-functions and after-change-functions
2202 to nil--but in a way that errors don't know about.
2203 That way, if there's an error in them, they will stay nil. */
2204 before_change_functions
= Vbefore_change_functions
;
2205 after_change_functions
= Vafter_change_functions
;
2206 Vbefore_change_functions
= Qnil
;
2207 Vafter_change_functions
= Qnil
;
2208 GCPRO2 (before_change_functions
, after_change_functions
);
2210 /* Actually run the hook functions. */
2211 args
[0] = Qafter_change_functions
;
2212 XSETFASTINT (args
[1], charpos
);
2213 XSETFASTINT (args
[2], charpos
+ lenins
);
2214 XSETFASTINT (args
[3], lendel
);
2215 run_hook_list_with_args (after_change_functions
,
2218 /* "Unbind" the variables we "bound" to nil. */
2219 Vbefore_change_functions
= before_change_functions
;
2220 Vafter_change_functions
= after_change_functions
;
2224 if (!NILP (current_buffer
->overlays_before
)
2225 || !NILP (current_buffer
->overlays_after
))
2226 report_overlay_modification (make_number (charpos
),
2227 make_number (charpos
+ lenins
),
2229 make_number (charpos
),
2230 make_number (charpos
+ lenins
),
2231 make_number (lendel
));
2233 /* After an insertion, call the text properties
2234 insert-behind-hooks or insert-in-front-hooks. */
2236 report_interval_modification (charpos
, charpos
+ lenins
);
2240 Fcombine_after_change_execute_1 (val
)
2243 Vcombine_after_change_calls
= val
;
2247 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2248 Scombine_after_change_execute
, 0, 0, 0,
2249 "This function is for use internally in `combine-after-change-calls'.")
2252 register Lisp_Object val
;
2253 int count
= specpdl_ptr
- specpdl
;
2254 int beg
, end
, change
;
2258 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2260 Fset_buffer (combine_after_change_buffer
);
2262 /* # chars unchanged at beginning of buffer. */
2264 /* # chars unchanged at end of buffer. */
2266 /* Total amount of insertion (negative for deletion). */
2269 /* Scan the various individual changes,
2270 accumulating the range info in BEG, END and CHANGE. */
2271 for (tail
= combine_after_change_list
; CONSP (tail
);
2272 tail
= XCONS (tail
)->cdr
)
2275 int thisbeg
, thisend
, thischange
;
2277 /* Extract the info from the next element. */
2278 elt
= XCONS (tail
)->car
;
2281 thisbeg
= XINT (XCONS (elt
)->car
);
2283 elt
= XCONS (elt
)->cdr
;
2286 thisend
= XINT (XCONS (elt
)->car
);
2288 elt
= XCONS (elt
)->cdr
;
2291 thischange
= XINT (XCONS (elt
)->car
);
2293 /* Merge this range into the accumulated range. */
2294 change
+= thischange
;
2301 /* Get the current start and end positions of the range
2302 that was changed. */
2306 /* We are about to handle these, so discard them. */
2307 combine_after_change_list
= Qnil
;
2309 /* Now run the after-change functions for real.
2310 Turn off the flag that defers them. */
2311 record_unwind_protect (Fcombine_after_change_execute_1
,
2312 Vcombine_after_change_calls
);
2313 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2315 return unbind_to (count
, val
);
2320 staticpro (&combine_after_change_list
);
2321 combine_after_change_list
= Qnil
;
2323 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2324 "Used internally by the `combine-after-change-calls' macro.");
2325 Vcombine_after_change_calls
= Qnil
;
2327 defsubr (&Scombine_after_change_execute
);