1 /* Buffer insertion/deletion and gap motion for GNU Emacs.
2 Copyright (C) 1985, 86,93,94,95,97,98, 1999 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"
29 #include "region-cache.h"
35 #define min(x, y) ((x) < (y) ? (x) : (y))
36 #define max(x, y) ((x) > (y) ? (x) : (y))
38 static void insert_from_string_1
P_ ((Lisp_Object
, int, int, int, int, int, int));
39 static void insert_from_buffer_1 ();
40 static void gap_left
P_ ((int, int, int));
41 static void gap_right
P_ ((int, int));
42 static void adjust_markers_gap_motion
P_ ((int, int, int));
43 static void adjust_markers_for_insert
P_ ((int, int, int, int, int));
44 void adjust_markers_for_delete
P_ ((int, int, int, int));
45 static void adjust_markers_for_replace
P_ ((int, int, int, int, int, int));
46 static void adjust_point
P_ ((int, int));
48 Lisp_Object
Fcombine_after_change_execute ();
50 /* Non-nil means don't call the after-change-functions right away,
51 just record an element in Vcombine_after_change_calls_list. */
52 Lisp_Object Vcombine_after_change_calls
;
54 /* List of elements of the form (BEG-UNCHANGED END-UNCHANGED CHANGE-AMOUNT)
55 describing changes which happened while combine_after_change_calls
56 was nonzero. We use this to decide how to call them
57 once the deferral ends.
60 BEG-UNCHANGED is the number of chars before the changed range.
61 END-UNCHANGED is the number of chars after the changed range,
62 and CHANGE-AMOUNT is the number of characters inserted by the change
63 (negative for a deletion). */
64 Lisp_Object combine_after_change_list
;
66 /* Buffer which combine_after_change_list is about. */
67 Lisp_Object combine_after_change_buffer
;
69 /* Check all markers in the current buffer, looking for something invalid. */
71 static int check_markers_debug_flag
;
73 #define CHECK_MARKERS() \
74 if (check_markers_debug_flag) \
81 register Lisp_Object tail
;
82 int multibyte
= ! NILP (current_buffer
->enable_multibyte_characters
);
84 tail
= BUF_MARKERS (current_buffer
);
88 if (XMARKER (tail
)->buffer
->text
!= current_buffer
->text
)
90 if (XMARKER (tail
)->charpos
> Z
)
92 if (XMARKER (tail
)->bytepos
> Z_BYTE
)
94 if (multibyte
&& ! CHAR_HEAD_P (FETCH_BYTE (XMARKER (tail
)->bytepos
)))
97 tail
= XMARKER (tail
)->chain
;
101 /* Move gap to position CHARPOS.
102 Note that this can quit! */
108 move_gap_both (charpos
, charpos_to_bytepos (charpos
));
111 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
112 Note that this can quit! */
115 move_gap_both (charpos
, bytepos
)
116 int charpos
, bytepos
;
118 if (bytepos
< GPT_BYTE
)
119 gap_left (charpos
, bytepos
, 0);
120 else if (bytepos
> GPT_BYTE
)
121 gap_right (charpos
, bytepos
);
124 /* Move the gap to a position less than the current GPT.
125 BYTEPOS describes the new position as a byte position,
126 and CHARPOS is the corresponding char position.
127 If NEWGAP is nonzero, then don't update beg_unchanged and end_unchanged. */
130 gap_left (charpos
, bytepos
, newgap
)
131 register int charpos
, bytepos
;
134 register unsigned char *to
, *from
;
139 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
146 /* Now copy the characters. To move the gap down,
147 copy characters up. */
151 /* I gets number of characters left to copy. */
152 i
= new_s1
- bytepos
;
155 /* If a quit is requested, stop copying now.
156 Change BYTEPOS to be where we have actually moved the gap to. */
160 charpos
= BYTE_TO_CHAR (bytepos
);
163 /* Move at most 32000 chars before checking again for a quit. */
168 /* bcopy is safe if the two areas of memory do not overlap
169 or on systems where bcopy is always safe for moving upward. */
170 && (BCOPY_UPWARD_SAFE
171 || to
- from
>= 128))
173 /* If overlap is not safe, avoid it by not moving too many
174 characters at once. */
175 if (!BCOPY_UPWARD_SAFE
&& i
> to
- from
)
190 /* Adjust markers, and buffer data structure, to put the gap at BYTEPOS.
191 BYTEPOS is where the loop above stopped, which may be what was specified
192 or may be where a quit was detected. */
193 adjust_markers_gap_motion (bytepos
, GPT_BYTE
, GAP_SIZE
);
196 if (bytepos
< charpos
)
198 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
202 /* Move the gap to a position greater than than the current GPT.
203 BYTEPOS describes the new position as a byte position,
204 and CHARPOS is the corresponding char position. */
207 gap_right (charpos
, bytepos
)
208 register int charpos
, bytepos
;
210 register unsigned char *to
, *from
;
214 BUF_COMPUTE_UNCHANGED (current_buffer
, charpos
, GPT
);
221 /* Now copy the characters. To move the gap up,
222 copy characters down. */
226 /* I gets number of characters left to copy. */
227 i
= bytepos
- new_s1
;
230 /* If a quit is requested, stop copying now.
231 Change BYTEPOS to be where we have actually moved the gap to. */
235 charpos
= BYTE_TO_CHAR (bytepos
);
238 /* Move at most 32000 chars before checking again for a quit. */
243 /* bcopy is safe if the two areas of memory do not overlap
244 or on systems where bcopy is always safe for moving downward. */
245 && (BCOPY_DOWNWARD_SAFE
246 || from
- to
>= 128))
248 /* If overlap is not safe, avoid it by not moving too many
249 characters at once. */
250 if (!BCOPY_DOWNWARD_SAFE
&& i
> from
- to
)
265 adjust_markers_gap_motion (GPT_BYTE
+ GAP_SIZE
, bytepos
+ GAP_SIZE
,
269 if (bytepos
< charpos
)
271 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
275 /* Add AMOUNT to the byte position of every marker in the current buffer
276 whose current byte position is between FROM (exclusive) and TO (inclusive).
278 Also, any markers past the outside of that interval, in the direction
279 of adjustment, are first moved back to the near end of the interval
280 and then adjusted by AMOUNT.
282 When the latter adjustment is done, if AMOUNT is negative,
283 we record the adjustment for undo. (This case happens only for
286 The markers' character positions are not altered,
287 because gap motion does not affect character positions. */
289 int adjust_markers_test
;
292 adjust_markers_gap_motion (from
, to
, amount
)
293 register int from
, to
, amount
;
295 /* Now that a marker has a bytepos, not counting the gap,
296 nothing needs to be done here. */
299 register struct Lisp_Marker
*m
;
302 marker
= BUF_MARKERS (current_buffer
);
304 while (!NILP (marker
))
306 m
= XMARKER (marker
);
310 if (mpos
> to
&& mpos
< to
+ amount
)
312 if (adjust_markers_test
)
319 /* Here's the case where a marker is inside text being deleted.
320 AMOUNT can be negative for gap motion, too,
321 but then this range contains no markers. */
322 if (mpos
> from
+ amount
&& mpos
<= from
)
324 if (adjust_markers_test
)
326 mpos
= from
+ amount
;
329 if (mpos
> from
&& mpos
<= to
)
337 /* Adjust all markers for a deletion
338 whose range in bytes is FROM_BYTE to TO_BYTE.
339 The range in charpos is FROM to TO.
341 This function assumes that the gap is adjacent to
342 or inside of the range being deleted. */
345 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
)
346 register int from
, from_byte
, to
, to_byte
;
349 register struct Lisp_Marker
*m
;
350 register int charpos
;
352 marker
= BUF_MARKERS (current_buffer
);
354 while (!NILP (marker
))
356 m
= XMARKER (marker
);
357 charpos
= m
->charpos
;
362 /* If the marker is after the deletion,
363 relocate by number of chars / bytes deleted. */
366 m
->charpos
-= to
- from
;
367 m
->bytepos
-= to_byte
- from_byte
;
370 /* Here's the case where a marker is inside text being deleted. */
371 else if (charpos
> from
)
373 record_marker_adjustment (marker
, from
- charpos
);
375 m
->bytepos
= from_byte
;
383 /* Adjust markers for an insertion that stretches from FROM / FROM_BYTE
384 to TO / TO_BYTE. We have to relocate the charpos of every marker
385 that points after the insertion (but not their bytepos).
387 When a marker points at the insertion point,
388 we advance it if either its insertion-type is t
389 or BEFORE_MARKERS is true. */
392 adjust_markers_for_insert (from
, from_byte
, to
, to_byte
, before_markers
)
393 register int from
, from_byte
, to
, to_byte
;
398 int nchars
= to
- from
;
399 int nbytes
= to_byte
- from_byte
;
401 marker
= BUF_MARKERS (current_buffer
);
403 while (!NILP (marker
))
405 register struct Lisp_Marker
*m
= XMARKER (marker
);
407 /* In a single-byte buffer, a marker's two positions must be
411 if (m
->charpos
!= m
->bytepos
)
415 if (m
->bytepos
== from_byte
)
417 if (m
->insertion_type
|| before_markers
)
419 m
->bytepos
= to_byte
;
421 if (m
->insertion_type
)
425 else if (m
->bytepos
> from_byte
)
427 m
->bytepos
+= nbytes
;
428 m
->charpos
+= nchars
;
434 /* Adjusting only markers whose insertion-type is t may result in
435 disordered overlays in the slot `overlays_before'. */
437 fix_overlays_before (current_buffer
, from
, to
);
440 /* Adjust point for an insertion of NBYTES bytes, which are NCHARS characters.
442 This is used only when the value of point changes due to an insert
443 or delete; it does not represent a conceptual change in point as a
444 marker. In particular, point is not crossing any interval
445 boundaries, so there's no need to use the usual SET_PT macro. In
446 fact it would be incorrect to do so, because either the old or the
447 new value of point is out of sync with the current set of
451 adjust_point (nchars
, nbytes
)
454 BUF_PT (current_buffer
) += nchars
;
455 BUF_PT_BYTE (current_buffer
) += nbytes
;
457 /* In a single-byte buffer, the two positions must be equal. */
463 /* Adjust markers for a replacement of a text at FROM (FROM_BYTE) of
464 length OLD_CHARS (OLD_BYTES) to a new text of length NEW_CHARS
468 adjust_markers_for_replace (from
, from_byte
, old_chars
, old_bytes
,
469 new_chars
, new_bytes
)
470 int from
, from_byte
, old_chars
, old_bytes
, new_chars
, new_bytes
;
472 Lisp_Object marker
= BUF_MARKERS (current_buffer
);
473 int prev_to_byte
= from_byte
+ old_bytes
;
474 int diff_chars
= new_chars
- old_chars
;
475 int diff_bytes
= new_bytes
- old_bytes
;
477 while (!NILP (marker
))
479 register struct Lisp_Marker
*m
= XMARKER (marker
);
481 if (m
->bytepos
>= prev_to_byte
483 /* If this is an insertion (replacing 0 chars),
484 reject the case of a marker that is at the
485 insertion point and should stay before the insertion. */
486 || m
->bytepos
> from_byte
|| m
->insertion_type
))
488 m
->charpos
= min (from
+ new_chars
, m
->charpos
+ diff_chars
);
489 m
->bytepos
= min (from_byte
+ new_bytes
, m
->bytepos
+ diff_bytes
);
491 else if (m
->bytepos
>= from_byte
)
494 m
->bytepos
= from_byte
;
504 /* Make the gap NBYTES_ADDED bytes longer. */
507 make_gap (nbytes_added
)
510 unsigned char *result
;
513 int real_gap_loc_byte
;
516 /* If we have to get more space, get enough to last a while. */
517 nbytes_added
+= 2000;
519 /* Don't allow a buffer size that won't fit in an int
520 even if it will fit in a Lisp integer.
521 That won't work because so many places use `int'. */
523 if (Z_BYTE
- BEG_BYTE
+ GAP_SIZE
+ nbytes_added
524 >= ((unsigned) 1 << (min (BITS_PER_INT
, VALBITS
) - 1)))
525 error ("Buffer exceeds maximum size");
528 /* We allocate extra 1-byte `\0' at the tail for anchoring a search. */
529 result
= BUFFER_REALLOC (BEG_ADDR
, (Z_BYTE
- BEG_BYTE
530 + GAP_SIZE
+ nbytes_added
+ 1));
538 /* We can't unblock until the new address is properly stored. */
542 /* Prevent quitting in move_gap. */
547 real_gap_loc_byte
= GPT_BYTE
;
548 old_gap_size
= GAP_SIZE
;
550 /* Call the newly allocated space a gap at the end of the whole space. */
552 GPT_BYTE
= Z_BYTE
+ GAP_SIZE
;
553 GAP_SIZE
= nbytes_added
;
555 /* Move the new gap down to be consecutive with the end of the old one.
556 This adjusts the markers properly too. */
557 gap_left (real_gap_loc
+ old_gap_size
, real_gap_loc_byte
+ old_gap_size
, 1);
559 /* Now combine the two into one large gap. */
560 GAP_SIZE
+= old_gap_size
;
562 GPT_BYTE
= real_gap_loc_byte
;
570 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
571 FROM_MULTIBYTE says whether the incoming text is multibyte.
572 TO_MULTIBYTE says whether to store the text as multibyte.
573 If FROM_MULTIBYTE != TO_MULTIBYTE, we convert.
575 Return the number of bytes stored at TO_ADDR. */
578 copy_text (from_addr
, to_addr
, nbytes
,
579 from_multibyte
, to_multibyte
)
580 unsigned char *from_addr
;
581 unsigned char *to_addr
;
583 int from_multibyte
, to_multibyte
;
585 if (from_multibyte
== to_multibyte
)
587 bcopy (from_addr
, to_addr
, nbytes
);
590 else if (from_multibyte
)
593 int bytes_left
= nbytes
;
594 Lisp_Object tbl
= Qnil
;
596 /* We set the variable tbl to the reverse table of
597 Vnonascii_translation_table in advance. */
598 if (CHAR_TABLE_P (Vnonascii_translation_table
))
600 tbl
= Fchar_table_extra_slot (Vnonascii_translation_table
,
602 if (!CHAR_TABLE_P (tbl
))
606 /* Convert multibyte to single byte. */
607 while (bytes_left
> 0)
610 c
= STRING_CHAR_AND_LENGTH (from_addr
, bytes_left
, thislen
);
611 if (!SINGLE_BYTE_CHAR_P (c
))
612 c
= multibyte_char_to_unibyte (c
, tbl
);
614 from_addr
+= thislen
;
615 bytes_left
-= thislen
;
622 unsigned char *initial_to_addr
= to_addr
;
624 /* Convert single-byte to multibyte. */
627 int c
= *from_addr
++;
631 c
= unibyte_char_to_multibyte (c
);
632 to_addr
+= CHAR_STRING (c
, to_addr
);
636 /* Special case for speed. */
637 *to_addr
++ = c
, nbytes
--;
639 return to_addr
- initial_to_addr
;
643 /* Return the number of bytes it would take
644 to convert some single-byte text to multibyte.
645 The single-byte text consists of NBYTES bytes at PTR. */
648 count_size_as_multibyte (ptr
, nbytes
)
653 int outgoing_nbytes
= 0;
655 for (i
= 0; i
< nbytes
; i
++)
657 unsigned int c
= *ptr
++;
663 c
= unibyte_char_to_multibyte (c
);
664 outgoing_nbytes
+= CHAR_BYTES (c
);
668 return outgoing_nbytes
;
671 /* Insert a string of specified length before point.
672 This function judges multibyteness based on
673 enable_multibyte_characters in the current buffer;
674 it never converts between single-byte and multibyte.
676 DO NOT use this for the contents of a Lisp string or a Lisp buffer!
677 prepare_to_modify_buffer could relocate the text. */
680 insert (string
, nbytes
)
681 register unsigned char *string
;
687 insert_1 (string
, nbytes
, 0, 1, 0);
688 signal_after_change (opoint
, 0, PT
- opoint
);
689 update_compositions (opoint
, PT
, CHECK_BORDER
);
693 /* Likewise, but inherit text properties from neighboring characters. */
696 insert_and_inherit (string
, nbytes
)
697 register unsigned char *string
;
703 insert_1 (string
, nbytes
, 1, 1, 0);
704 signal_after_change (opoint
, 0, PT
- opoint
);
705 update_compositions (opoint
, PT
, CHECK_BORDER
);
709 /* Insert the character C before point. Do not inherit text properties. */
715 unsigned char str
[MAX_MULTIBYTE_LENGTH
];
718 if (! NILP (current_buffer
->enable_multibyte_characters
))
719 len
= CHAR_STRING (c
, str
);
729 /* Insert the null-terminated string S before point. */
735 insert (s
, strlen (s
));
738 /* Like `insert' except that all markers pointing at the place where
739 the insertion happens are adjusted to point after it.
740 Don't use this function to insert part of a Lisp string,
741 since gc could happen and relocate it. */
744 insert_before_markers (string
, nbytes
)
745 unsigned char *string
;
752 insert_1 (string
, nbytes
, 0, 1, 1);
753 signal_after_change (opoint
, 0, PT
- opoint
);
754 update_compositions (opoint
, PT
, CHECK_BORDER
);
758 /* Likewise, but inherit text properties from neighboring characters. */
761 insert_before_markers_and_inherit (string
, nbytes
)
762 unsigned char *string
;
769 insert_1 (string
, nbytes
, 1, 1, 1);
770 signal_after_change (opoint
, 0, PT
- opoint
);
771 update_compositions (opoint
, PT
, CHECK_BORDER
);
775 /* Subroutine used by the insert functions above. */
778 insert_1 (string
, nbytes
, inherit
, prepare
, before_markers
)
779 register unsigned char *string
;
781 int inherit
, prepare
, before_markers
;
783 insert_1_both (string
, chars_in_text (string
, nbytes
), nbytes
,
784 inherit
, prepare
, before_markers
);
788 #ifdef BYTE_COMBINING_DEBUG
790 /* See if the bytes before POS/POS_BYTE combine with bytes
791 at the start of STRING to form a single character.
792 If so, return the number of bytes at the start of STRING
793 which combine in this way. Otherwise, return 0. */
796 count_combining_before (string
, length
, pos
, pos_byte
)
797 unsigned char *string
;
801 int len
, combining_bytes
;
804 if (NILP (current_buffer
->enable_multibyte_characters
))
807 /* At first, we can exclude the following cases:
808 (1) STRING[0] can't be a following byte of multibyte sequence.
809 (2) POS is the start of the current buffer.
810 (3) A character before POS is not a multibyte character. */
811 if (length
== 0 || CHAR_HEAD_P (*string
)) /* case (1) */
813 if (pos_byte
== BEG_BYTE
) /* case (2) */
816 p
= BYTE_POS_ADDR (pos_byte
- 1);
817 while (! CHAR_HEAD_P (*p
)) p
--, len
++;
818 if (! BASE_LEADING_CODE_P (*p
)) /* case (3) */
821 combining_bytes
= BYTES_BY_CHAR_HEAD (*p
) - len
;
822 if (combining_bytes
<= 0)
823 /* The character preceding POS is, complete and no room for
824 combining bytes (combining_bytes == 0), or an independent 8-bit
825 character (combining_bytes < 0). */
828 /* We have a combination situation. Count the bytes at STRING that
831 while (!CHAR_HEAD_P (*p
) && p
< string
+ length
)
834 return (combining_bytes
< p
- string
? combining_bytes
: p
- string
);
837 /* See if the bytes after POS/POS_BYTE combine with bytes
838 at the end of STRING to form a single character.
839 If so, return the number of bytes after POS/POS_BYTE
840 which combine in this way. Otherwise, return 0. */
843 count_combining_after (string
, length
, pos
, pos_byte
)
844 unsigned char *string
;
848 int opos_byte
= pos_byte
;
853 if (NILP (current_buffer
->enable_multibyte_characters
))
856 /* At first, we can exclude the following cases:
857 (1) The last byte of STRING is an ASCII.
858 (2) POS is the last of the current buffer.
859 (3) A character at POS can't be a following byte of multibyte
861 if (length
> 0 && ASCII_BYTE_P (string
[length
- 1])) /* case (1) */
863 if (pos_byte
== Z_BYTE
) /* case (2) */
865 bufp
= BYTE_POS_ADDR (pos_byte
);
866 if (CHAR_HEAD_P (*bufp
)) /* case (3) */
870 while (i
>= 0 && ! CHAR_HEAD_P (string
[i
]))
876 /* All characters in STRING are not character head. We must
877 check also preceding bytes at POS. We are sure that the gap
879 unsigned char *p
= BEG_ADDR
;
881 while (i
>= 0 && ! CHAR_HEAD_P (p
[i
]))
883 if (i
< 0 || !BASE_LEADING_CODE_P (p
[i
]))
886 bytes
= BYTES_BY_CHAR_HEAD (p
[i
]);
887 return (bytes
<= pos_byte
- 1 - i
+ length
889 : bytes
- (pos_byte
- 1 - i
+ length
));
891 if (!BASE_LEADING_CODE_P (string
[i
]))
894 bytes
= BYTES_BY_CHAR_HEAD (string
[i
]) - (length
- i
);
896 while (!CHAR_HEAD_P (*bufp
)) bufp
++, pos_byte
++;
898 return (bytes
<= pos_byte
- opos_byte
? bytes
: pos_byte
- opos_byte
);
904 /* Insert a sequence of NCHARS chars which occupy NBYTES bytes
905 starting at STRING. INHERIT, PREPARE and BEFORE_MARKERS
906 are the same as in insert_1. */
909 insert_1_both (string
, nchars
, nbytes
, inherit
, prepare
, before_markers
)
910 register unsigned char *string
;
911 register int nchars
, nbytes
;
912 int inherit
, prepare
, before_markers
;
914 if (NILP (current_buffer
->enable_multibyte_characters
))
918 /* Do this before moving and increasing the gap,
919 because the before-change hooks might move the gap
920 or make it smaller. */
921 prepare_to_modify_buffer (PT
, PT
, NULL
);
924 move_gap_both (PT
, PT_BYTE
);
925 if (GAP_SIZE
< nbytes
)
926 make_gap (nbytes
- GAP_SIZE
);
928 #ifdef BYTE_COMBINING_DEBUG
929 if (count_combining_before (string
, nbytes
, PT
, PT_BYTE
)
930 || count_combining_after (string
, nbytes
, PT
, PT_BYTE
))
934 /* Record deletion of the surrounding text that combines with
935 the insertion. This, together with recording the insertion,
936 will add up to the right stuff in the undo list. */
937 record_insert (PT
, nchars
);
940 bcopy (string
, GPT_ADDR
, nbytes
);
949 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
954 adjust_overlays_for_insert (PT
, nchars
);
955 adjust_markers_for_insert (PT
, PT_BYTE
,
956 PT
+ nchars
, PT_BYTE
+ nbytes
,
959 if (BUF_INTERVALS (current_buffer
) != 0)
960 offset_intervals (current_buffer
, PT
, nchars
);
962 if (!inherit
&& BUF_INTERVALS (current_buffer
) != 0)
963 set_text_properties (make_number (PT
), make_number (PT
+ nchars
),
966 adjust_point (nchars
, nbytes
);
971 /* Insert the part of the text of STRING, a Lisp object assumed to be
972 of type string, consisting of the LENGTH characters (LENGTH_BYTE bytes)
973 starting at position POS / POS_BYTE. If the text of STRING has properties,
974 copy them into the buffer.
976 It does not work to use `insert' for this, because a GC could happen
977 before we bcopy the stuff into the buffer, and relocate the string
978 without insert noticing. */
981 insert_from_string (string
, pos
, pos_byte
, length
, length_byte
, inherit
)
983 register int pos
, pos_byte
, length
, length_byte
;
987 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
989 signal_after_change (opoint
, 0, PT
- opoint
);
990 update_compositions (opoint
, PT
, CHECK_BORDER
);
993 /* Like `insert_from_string' except that all markers pointing
994 at the place where the insertion happens are adjusted to point after it. */
997 insert_from_string_before_markers (string
, pos
, pos_byte
,
998 length
, length_byte
, inherit
)
1000 register int pos
, pos_byte
, length
, length_byte
;
1004 insert_from_string_1 (string
, pos
, pos_byte
, length
, length_byte
,
1006 signal_after_change (opoint
, 0, PT
- opoint
);
1007 update_compositions (opoint
, PT
, CHECK_BORDER
);
1010 /* Subroutine of the insertion functions above. */
1013 insert_from_string_1 (string
, pos
, pos_byte
, nchars
, nbytes
,
1014 inherit
, before_markers
)
1016 register int pos
, pos_byte
, nchars
, nbytes
;
1017 int inherit
, before_markers
;
1019 struct gcpro gcpro1
;
1020 int outgoing_nbytes
= nbytes
;
1023 /* Make OUTGOING_NBYTES describe the text
1024 as it will be inserted in this buffer. */
1026 if (NILP (current_buffer
->enable_multibyte_characters
))
1027 outgoing_nbytes
= nchars
;
1028 else if (! STRING_MULTIBYTE (string
))
1030 = count_size_as_multibyte (&XSTRING (string
)->data
[pos_byte
],
1034 /* Do this before moving and increasing the gap,
1035 because the before-change hooks might move the gap
1036 or make it smaller. */
1037 prepare_to_modify_buffer (PT
, PT
, NULL
);
1040 move_gap_both (PT
, PT_BYTE
);
1041 if (GAP_SIZE
< outgoing_nbytes
)
1042 make_gap (outgoing_nbytes
- GAP_SIZE
);
1045 /* Copy the string text into the buffer, perhaps converting
1046 between single-byte and multibyte. */
1047 copy_text (XSTRING (string
)->data
+ pos_byte
, GPT_ADDR
, nbytes
,
1048 STRING_MULTIBYTE (string
),
1049 ! NILP (current_buffer
->enable_multibyte_characters
));
1051 #ifdef BYTE_COMBINING_DEBUG
1052 /* We have copied text into the gap, but we have not altered
1053 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1054 to these functions and get the same results as we would
1055 have got earlier on. Meanwhile, PT_ADDR does point to
1056 the text that has been stored by copy_text. */
1057 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1058 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1062 record_insert (PT
, nchars
);
1065 GAP_SIZE
-= outgoing_nbytes
;
1069 GPT_BYTE
+= outgoing_nbytes
;
1070 ZV_BYTE
+= outgoing_nbytes
;
1071 Z_BYTE
+= outgoing_nbytes
;
1072 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1077 adjust_overlays_for_insert (PT
, nchars
);
1078 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1079 PT_BYTE
+ outgoing_nbytes
,
1082 offset_intervals (current_buffer
, PT
, nchars
);
1084 intervals
= XSTRING (string
)->intervals
;
1085 /* Get the intervals for the part of the string we are inserting. */
1086 if (nbytes
< STRING_BYTES (XSTRING (string
)))
1087 intervals
= copy_intervals (intervals
, pos
, nchars
);
1089 /* Insert those intervals. */
1090 graft_intervals_into_buffer (intervals
, PT
, nchars
,
1091 current_buffer
, inherit
);
1093 adjust_point (nchars
, outgoing_nbytes
);
1096 /* Insert text from BUF, NCHARS characters starting at CHARPOS, into the
1097 current buffer. If the text in BUF has properties, they are absorbed
1098 into the current buffer.
1100 It does not work to use `insert' for this, because a malloc could happen
1101 and relocate BUF's text before the bcopy happens. */
1104 insert_from_buffer (buf
, charpos
, nchars
, inherit
)
1106 int charpos
, nchars
;
1111 insert_from_buffer_1 (buf
, charpos
, nchars
, inherit
);
1112 signal_after_change (opoint
, 0, PT
- opoint
);
1113 update_compositions (opoint
, PT
, CHECK_BORDER
);
1117 insert_from_buffer_1 (buf
, from
, nchars
, inherit
)
1122 register Lisp_Object temp
;
1123 int chunk
, chunk_expanded
;
1124 int from_byte
= buf_charpos_to_bytepos (buf
, from
);
1125 int to_byte
= buf_charpos_to_bytepos (buf
, from
+ nchars
);
1126 int incoming_nbytes
= to_byte
- from_byte
;
1127 int outgoing_nbytes
= incoming_nbytes
;
1130 /* Make OUTGOING_NBYTES describe the text
1131 as it will be inserted in this buffer. */
1133 if (NILP (current_buffer
->enable_multibyte_characters
))
1134 outgoing_nbytes
= nchars
;
1135 else if (NILP (buf
->enable_multibyte_characters
))
1137 int outgoing_before_gap
= 0;
1138 int outgoing_after_gap
= 0;
1140 if (from
< BUF_GPT (buf
))
1142 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1143 if (chunk
> incoming_nbytes
)
1144 chunk
= incoming_nbytes
;
1146 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
, from_byte
),
1152 if (chunk
< incoming_nbytes
)
1154 = count_size_as_multibyte (BUF_BYTE_ADDRESS (buf
,
1156 incoming_nbytes
- chunk
);
1158 outgoing_nbytes
= outgoing_before_gap
+ outgoing_after_gap
;
1161 /* Make sure point-max won't overflow after this insertion. */
1162 XSETINT (temp
, outgoing_nbytes
+ Z
);
1163 if (outgoing_nbytes
+ Z
!= XINT (temp
))
1164 error ("Maximum buffer size exceeded");
1166 /* Do this before moving and increasing the gap,
1167 because the before-change hooks might move the gap
1168 or make it smaller. */
1169 prepare_to_modify_buffer (PT
, PT
, NULL
);
1172 move_gap_both (PT
, PT_BYTE
);
1173 if (GAP_SIZE
< outgoing_nbytes
)
1174 make_gap (outgoing_nbytes
- GAP_SIZE
);
1176 if (from
< BUF_GPT (buf
))
1178 chunk
= BUF_GPT_BYTE (buf
) - from_byte
;
1179 if (chunk
> incoming_nbytes
)
1180 chunk
= incoming_nbytes
;
1181 /* Record number of output bytes, so we know where
1182 to put the output from the second copy_text. */
1184 = copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
),
1186 ! NILP (buf
->enable_multibyte_characters
),
1187 ! NILP (current_buffer
->enable_multibyte_characters
));
1190 chunk_expanded
= chunk
= 0;
1192 if (chunk
< incoming_nbytes
)
1193 copy_text (BUF_BYTE_ADDRESS (buf
, from_byte
+ chunk
),
1194 GPT_ADDR
+ chunk_expanded
, incoming_nbytes
- chunk
,
1195 ! NILP (buf
->enable_multibyte_characters
),
1196 ! NILP (current_buffer
->enable_multibyte_characters
));
1198 #ifdef BYTE_COMBINING_DEBUG
1199 /* We have copied text into the gap, but we have not altered
1200 PT or PT_BYTE yet. So we can pass PT and PT_BYTE
1201 to these functions and get the same results as we would
1202 have got earlier on. Meanwhile, GPT_ADDR does point to
1203 the text that has been stored by copy_text. */
1204 if (count_combining_before (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
)
1205 || count_combining_after (GPT_ADDR
, outgoing_nbytes
, PT
, PT_BYTE
))
1209 record_insert (PT
, nchars
);
1212 GAP_SIZE
-= outgoing_nbytes
;
1216 GPT_BYTE
+= outgoing_nbytes
;
1217 ZV_BYTE
+= outgoing_nbytes
;
1218 Z_BYTE
+= outgoing_nbytes
;
1219 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1224 adjust_overlays_for_insert (PT
, nchars
);
1225 adjust_markers_for_insert (PT
, PT_BYTE
, PT
+ nchars
,
1226 PT_BYTE
+ outgoing_nbytes
,
1229 if (BUF_INTERVALS (current_buffer
) != 0)
1230 offset_intervals (current_buffer
, PT
, nchars
);
1232 /* Get the intervals for the part of the string we are inserting. */
1233 intervals
= BUF_INTERVALS (buf
);
1234 if (outgoing_nbytes
< BUF_Z_BYTE (buf
) - BUF_BEG_BYTE (buf
))
1236 if (buf
== current_buffer
&& PT
<= from
)
1238 intervals
= copy_intervals (intervals
, from
, nchars
);
1241 /* Insert those intervals. */
1242 graft_intervals_into_buffer (intervals
, PT
, nchars
, current_buffer
, inherit
);
1244 adjust_point (nchars
, outgoing_nbytes
);
1247 /* Record undo information and adjust markers and position keepers for
1248 a replacement of a text PREV_TEXT at FROM to a new text of LEN
1249 chars (LEN_BYTE bytes) which resides in the gap just after
1252 PREV_TEXT nil means the new text was just inserted. */
1255 adjust_after_replace (from
, from_byte
, prev_text
, len
, len_byte
)
1256 int from
, from_byte
, len
, len_byte
;
1257 Lisp_Object prev_text
;
1259 int nchars_del
= 0, nbytes_del
= 0;
1261 #ifdef BYTE_COMBINING_DEBUG
1262 if (count_combining_before (GPT_ADDR
, len_byte
, from
, from_byte
)
1263 || count_combining_after (GPT_ADDR
, len_byte
, from
, from_byte
))
1267 if (STRINGP (prev_text
))
1269 nchars_del
= XSTRING (prev_text
)->size
;
1270 nbytes_del
= STRING_BYTES (XSTRING (prev_text
));
1273 /* Update various buffer positions for the new text. */
1274 GAP_SIZE
-= len_byte
;
1276 ZV_BYTE
+= len_byte
; Z_BYTE
+= len_byte
;
1277 GPT
+= len
; GPT_BYTE
+= len_byte
;
1278 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1280 adjust_markers_for_replace (from
, from_byte
, nchars_del
, nbytes_del
,
1283 if (! EQ (current_buffer
->undo_list
, Qt
))
1286 record_delete (from
, prev_text
);
1287 record_insert (from
, len
);
1290 if (len
> nchars_del
)
1291 adjust_overlays_for_insert (from
, len
- nchars_del
);
1292 else if (len
< nchars_del
)
1293 adjust_overlays_for_delete (from
, nchars_del
- len
);
1294 if (BUF_INTERVALS (current_buffer
) != 0)
1296 offset_intervals (current_buffer
, from
, len
- nchars_del
);
1300 adjust_point (len
- nchars_del
, len_byte
- nbytes_del
);
1302 /* As byte combining will decrease Z, we must check this again. */
1303 if (Z
- GPT
< END_UNCHANGED
)
1304 END_UNCHANGED
= Z
- GPT
;
1309 evaporate_overlays (from
);
1313 /* Record undo information, adjust markers and position keepers for an
1314 insertion of a text from FROM (FROM_BYTE) to TO (TO_BYTE). The
1315 text already exists in the current buffer but character length (TO
1316 - FROM) may be incorrect, the correct length is NEWLEN. */
1319 adjust_after_insert (from
, from_byte
, to
, to_byte
, newlen
)
1320 int from
, from_byte
, to
, to_byte
, newlen
;
1322 int len
= to
- from
, len_byte
= to_byte
- from_byte
;
1325 move_gap_both (to
, to_byte
);
1326 GAP_SIZE
+= len_byte
;
1327 GPT
-= len
; GPT_BYTE
-= len_byte
;
1328 ZV
-= len
; ZV_BYTE
-= len_byte
;
1329 Z
-= len
; Z_BYTE
-= len_byte
;
1330 adjust_after_replace (from
, from_byte
, Qnil
, newlen
, len_byte
);
1333 /* Replace the text from character positions FROM to TO with NEW,
1334 If PREPARE is nonzero, call prepare_to_modify_buffer.
1335 If INHERIT, the newly inserted text should inherit text properties
1336 from the surrounding non-deleted text. */
1338 /* Note that this does not yet handle markers quite right.
1339 Also it needs to record a single undo-entry that does a replacement
1340 rather than a separate delete and insert.
1341 That way, undo will also handle markers properly.
1343 But if MARKERS is 0, don't relocate markers. */
1346 replace_range (from
, to
, new, prepare
, inherit
, markers
)
1348 int from
, to
, prepare
, inherit
, markers
;
1350 int inschars
= XSTRING (new)->size
;
1351 int insbytes
= STRING_BYTES (XSTRING (new));
1352 int from_byte
, to_byte
;
1353 int nbytes_del
, nchars_del
;
1354 register Lisp_Object temp
;
1355 struct gcpro gcpro1
;
1357 int outgoing_insbytes
= insbytes
;
1358 Lisp_Object deletion
;
1366 int range_length
= to
- from
;
1367 prepare_to_modify_buffer (from
, to
, &from
);
1368 to
= from
+ range_length
;
1373 /* Make args be valid */
1379 from_byte
= CHAR_TO_BYTE (from
);
1380 to_byte
= CHAR_TO_BYTE (to
);
1382 nchars_del
= to
- from
;
1383 nbytes_del
= to_byte
- from_byte
;
1385 if (nbytes_del
<= 0 && insbytes
== 0)
1388 /* Make OUTGOING_INSBYTES describe the text
1389 as it will be inserted in this buffer. */
1391 if (NILP (current_buffer
->enable_multibyte_characters
))
1392 outgoing_insbytes
= inschars
;
1393 else if (! STRING_MULTIBYTE (new))
1395 = count_size_as_multibyte (XSTRING (new)->data
, insbytes
);
1397 /* Make sure point-max won't overflow after this insertion. */
1398 XSETINT (temp
, Z_BYTE
- nbytes_del
+ insbytes
);
1399 if (Z_BYTE
- nbytes_del
+ insbytes
!= XINT (temp
))
1400 error ("Maximum buffer size exceeded");
1404 /* Make sure the gap is somewhere in or next to what we are deleting. */
1406 gap_right (from
, from_byte
);
1408 gap_left (to
, to_byte
, 0);
1410 /* Even if we don't record for undo, we must keep the original text
1411 because we may have to recover it because of inappropriate byte
1413 if (! EQ (current_buffer
->undo_list
, Qt
))
1414 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1417 /* Relocate all markers pointing into the new, larger gap
1418 to point at the end of the text before the gap.
1419 Do this before recording the deletion,
1420 so that undo handles this after reinserting the text. */
1421 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1423 GAP_SIZE
+= nbytes_del
;
1426 ZV_BYTE
-= nbytes_del
;
1427 Z_BYTE
-= nbytes_del
;
1429 GPT_BYTE
= from_byte
;
1430 *(GPT_ADDR
) = 0; /* Put an anchor. */
1435 if (GPT
- BEG
< BEG_UNCHANGED
)
1436 BEG_UNCHANGED
= GPT
- BEG
;
1437 if (Z
- GPT
< END_UNCHANGED
)
1438 END_UNCHANGED
= Z
- GPT
;
1440 if (GAP_SIZE
< insbytes
)
1441 make_gap (insbytes
- GAP_SIZE
);
1443 /* Copy the string text into the buffer, perhaps converting
1444 between single-byte and multibyte. */
1445 copy_text (XSTRING (new)->data
, GPT_ADDR
, insbytes
,
1446 STRING_MULTIBYTE (new),
1447 ! NILP (current_buffer
->enable_multibyte_characters
));
1449 #ifdef BYTE_COMBINING_DEBUG
1450 /* We have copied text into the gap, but we have not marked
1451 it as part of the buffer. So we can use the old FROM and FROM_BYTE
1452 here, for both the previous text and the following text.
1453 Meanwhile, GPT_ADDR does point to
1454 the text that has been stored by copy_text. */
1455 if (count_combining_before (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
)
1456 || count_combining_after (GPT_ADDR
, outgoing_insbytes
, from
, from_byte
))
1460 if (! EQ (current_buffer
->undo_list
, Qt
))
1462 record_delete (from
, deletion
);
1463 record_insert (from
, inschars
);
1466 GAP_SIZE
-= outgoing_insbytes
;
1470 GPT_BYTE
+= outgoing_insbytes
;
1471 ZV_BYTE
+= outgoing_insbytes
;
1472 Z_BYTE
+= outgoing_insbytes
;
1473 if (GAP_SIZE
> 0) *(GPT_ADDR
) = 0; /* Put an anchor. */
1478 /* Adjust the overlay center as needed. This must be done after
1479 adjusting the markers that bound the overlays. */
1480 adjust_overlays_for_delete (from
, nchars_del
);
1481 adjust_overlays_for_insert (from
, inschars
);
1483 adjust_markers_for_insert (from
, from_byte
,
1484 from
+ inschars
, from_byte
+ outgoing_insbytes
,
1487 offset_intervals (current_buffer
, from
, inschars
- nchars_del
);
1489 /* Get the intervals for the part of the string we are inserting--
1490 not including the combined-before bytes. */
1491 intervals
= XSTRING (new)->intervals
;
1492 /* Insert those intervals. */
1493 graft_intervals_into_buffer (intervals
, from
, inschars
,
1494 current_buffer
, inherit
);
1496 /* Relocate point as if it were a marker. */
1498 adjust_point ((from
+ inschars
- (PT
< to
? PT
: to
)),
1499 (from_byte
+ outgoing_insbytes
1500 - (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
)));
1502 if (outgoing_insbytes
== 0)
1503 evaporate_overlays (from
);
1510 signal_after_change (from
, nchars_del
, GPT
- from
);
1511 update_compositions (from
, GPT
, CHECK_BORDER
);
1514 /* Delete characters in current buffer
1515 from FROM up to (but not including) TO.
1516 If TO comes before FROM, we delete nothing. */
1519 del_range (from
, to
)
1520 register int from
, to
;
1522 del_range_1 (from
, to
, 1, 0);
1525 /* Like del_range; PREPARE says whether to call prepare_to_modify_buffer.
1526 RET_STRING says to return the deleted text. */
1529 del_range_1 (from
, to
, prepare
, ret_string
)
1530 int from
, to
, prepare
, ret_string
;
1532 int from_byte
, to_byte
;
1533 Lisp_Object deletion
;
1534 struct gcpro gcpro1
;
1536 /* Make args be valid */
1547 int range_length
= to
- from
;
1548 prepare_to_modify_buffer (from
, to
, &from
);
1549 to
= from
+ range_length
;
1552 from_byte
= CHAR_TO_BYTE (from
);
1553 to_byte
= CHAR_TO_BYTE (to
);
1555 deletion
= del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
);
1557 signal_after_change (from
, to
- from
, 0);
1558 update_compositions (from
, from
, CHECK_HEAD
);
1563 /* Like del_range_1 but args are byte positions, not char positions. */
1566 del_range_byte (from_byte
, to_byte
, prepare
)
1567 int from_byte
, to_byte
, prepare
;
1571 /* Make args be valid */
1572 if (from_byte
< BEGV_BYTE
)
1573 from_byte
= BEGV_BYTE
;
1574 if (to_byte
> ZV_BYTE
)
1577 if (to_byte
<= from_byte
)
1580 from
= BYTE_TO_CHAR (from_byte
);
1581 to
= BYTE_TO_CHAR (to_byte
);
1585 int old_from
= from
, old_to
= Z
- to
;
1586 int range_length
= to
- from
;
1587 prepare_to_modify_buffer (from
, to
, &from
);
1588 to
= from
+ range_length
;
1590 if (old_from
!= from
)
1591 from_byte
= CHAR_TO_BYTE (from
);
1592 if (old_to
== Z
- to
)
1593 to_byte
= CHAR_TO_BYTE (to
);
1596 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1597 signal_after_change (from
, to
- from
, 0);
1598 update_compositions (from
, from
, CHECK_HEAD
);
1601 /* Like del_range_1, but positions are specified both as charpos
1605 del_range_both (from
, from_byte
, to
, to_byte
, prepare
)
1606 int from
, from_byte
, to
, to_byte
, prepare
;
1608 /* Make args be valid */
1609 if (from_byte
< BEGV_BYTE
)
1610 from_byte
= BEGV_BYTE
;
1611 if (to_byte
> ZV_BYTE
)
1614 if (to_byte
<= from_byte
)
1624 int old_from
= from
, old_to
= Z
- to
;
1625 int range_length
= to
- from
;
1626 prepare_to_modify_buffer (from
, to
, &from
);
1627 to
= from
+ range_length
;
1629 if (old_from
!= from
)
1630 from_byte
= CHAR_TO_BYTE (from
);
1631 if (old_to
== Z
- to
)
1632 to_byte
= CHAR_TO_BYTE (to
);
1635 del_range_2 (from
, from_byte
, to
, to_byte
, 0);
1636 signal_after_change (from
, to
- from
, 0);
1637 update_compositions (from
, from
, CHECK_HEAD
);
1640 /* Delete a range of text, specified both as character positions
1641 and byte positions. FROM and TO are character positions,
1642 while FROM_BYTE and TO_BYTE are byte positions.
1643 If RET_STRING is true, the deleted area is returned as a string. */
1646 del_range_2 (from
, from_byte
, to
, to_byte
, ret_string
)
1647 int from
, from_byte
, to
, to_byte
, ret_string
;
1649 register int nbytes_del
, nchars_del
;
1650 Lisp_Object deletion
;
1654 nchars_del
= to
- from
;
1655 nbytes_del
= to_byte
- from_byte
;
1657 /* Make sure the gap is somewhere in or next to what we are deleting. */
1659 gap_right (from
, from_byte
);
1661 gap_left (to
, to_byte
, 0);
1663 #ifdef BYTE_COMBINING_DEBUG
1664 if (count_combining_before (BUF_BYTE_ADDRESS (current_buffer
, to_byte
),
1665 Z_BYTE
- to_byte
, from
, from_byte
))
1669 if (ret_string
|| ! EQ (current_buffer
->undo_list
, Qt
))
1670 deletion
= make_buffer_string_both (from
, from_byte
, to
, to_byte
, 1);
1674 /* Relocate all markers pointing into the new, larger gap
1675 to point at the end of the text before the gap.
1676 Do this before recording the deletion,
1677 so that undo handles this after reinserting the text. */
1678 adjust_markers_for_delete (from
, from_byte
, to
, to_byte
);
1680 if (! EQ (current_buffer
->undo_list
, Qt
))
1681 record_delete (from
, deletion
);
1684 /* Relocate point as if it were a marker. */
1686 adjust_point (from
- (PT
< to
? PT
: to
),
1687 from_byte
- (PT_BYTE
< to_byte
? PT_BYTE
: to_byte
));
1689 offset_intervals (current_buffer
, from
, - nchars_del
);
1691 /* Adjust the overlay center as needed. This must be done after
1692 adjusting the markers that bound the overlays. */
1693 adjust_overlays_for_delete (from
, nchars_del
);
1695 GAP_SIZE
+= nbytes_del
;
1696 ZV_BYTE
-= nbytes_del
;
1697 Z_BYTE
-= nbytes_del
;
1701 GPT_BYTE
= from_byte
;
1702 *(GPT_ADDR
) = 0; /* Put an anchor. */
1707 if (GPT
- BEG
< BEG_UNCHANGED
)
1708 BEG_UNCHANGED
= GPT
- BEG
;
1709 if (Z
- GPT
< END_UNCHANGED
)
1710 END_UNCHANGED
= Z
- GPT
;
1714 evaporate_overlays (from
);
1719 /* Call this if you're about to change the region of BUFFER from
1720 character positions START to END. This checks the read-only
1721 properties of the region, calls the necessary modification hooks,
1722 and warns the next redisplay that it should pay attention to that
1726 modify_region (buffer
, start
, end
)
1727 struct buffer
*buffer
;
1730 struct buffer
*old_buffer
= current_buffer
;
1732 if (buffer
!= old_buffer
)
1733 set_buffer_internal (buffer
);
1735 prepare_to_modify_buffer (start
, end
, NULL
);
1737 BUF_COMPUTE_UNCHANGED (buffer
, start
- 1, end
);
1739 if (MODIFF
<= SAVE_MODIFF
)
1740 record_first_change ();
1743 buffer
->point_before_scroll
= Qnil
;
1745 if (buffer
!= old_buffer
)
1746 set_buffer_internal (old_buffer
);
1749 /* Check that it is okay to modify the buffer between START and END,
1750 which are char positions.
1752 Run the before-change-function, if any. If intervals are in use,
1753 verify that the text to be modified is not read-only, and call
1754 any modification properties the text may have.
1756 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1757 by holding its value temporarily in a marker. */
1760 prepare_to_modify_buffer (start
, end
, preserve_ptr
)
1764 if (!NILP (current_buffer
->read_only
))
1765 Fbarf_if_buffer_read_only ();
1767 /* Let redisplay consider other windows than selected_window
1768 if modifying another buffer. */
1769 if (XBUFFER (XWINDOW (selected_window
)->buffer
) != current_buffer
)
1770 ++windows_or_buffers_changed
;
1772 if (BUF_INTERVALS (current_buffer
) != 0)
1776 Lisp_Object preserve_marker
;
1777 struct gcpro gcpro1
;
1778 preserve_marker
= Fcopy_marker (make_number (*preserve_ptr
), Qnil
);
1779 GCPRO1 (preserve_marker
);
1780 verify_interval_modification (current_buffer
, start
, end
);
1781 *preserve_ptr
= marker_position (preserve_marker
);
1782 unchain_marker (preserve_marker
);
1786 verify_interval_modification (current_buffer
, start
, end
);
1789 #ifdef CLASH_DETECTION
1790 if (!NILP (current_buffer
->file_truename
)
1791 /* Make binding buffer-file-name to nil effective. */
1792 && !NILP (current_buffer
->filename
)
1793 && SAVE_MODIFF
>= MODIFF
)
1794 lock_file (current_buffer
->file_truename
);
1796 /* At least warn if this file has changed on disk since it was visited. */
1797 if (!NILP (current_buffer
->filename
)
1798 && SAVE_MODIFF
>= MODIFF
1799 && NILP (Fverify_visited_file_modtime (Fcurrent_buffer ()))
1800 && !NILP (Ffile_exists_p (current_buffer
->filename
)))
1801 call1 (intern ("ask-user-about-supersession-threat"),
1802 current_buffer
->filename
);
1803 #endif /* not CLASH_DETECTION */
1805 signal_before_change (start
, end
, preserve_ptr
);
1807 if (current_buffer
->newline_cache
)
1808 invalidate_region_cache (current_buffer
,
1809 current_buffer
->newline_cache
,
1810 start
- BEG
, Z
- end
);
1811 if (current_buffer
->width_run_cache
)
1812 invalidate_region_cache (current_buffer
,
1813 current_buffer
->width_run_cache
,
1814 start
- BEG
, Z
- end
);
1816 Vdeactivate_mark
= Qt
;
1819 /* These macros work with an argument named `preserve_ptr'
1820 and a local variable named `preserve_marker'. */
1822 #define PRESERVE_VALUE \
1823 if (preserve_ptr && NILP (preserve_marker)) \
1824 preserve_marker = Fcopy_marker (make_number (*preserve_ptr), Qnil)
1826 #define RESTORE_VALUE \
1827 if (! NILP (preserve_marker)) \
1829 *preserve_ptr = marker_position (preserve_marker); \
1830 unchain_marker (preserve_marker); \
1833 #define PRESERVE_START_END \
1834 if (NILP (start_marker)) \
1835 start_marker = Fcopy_marker (start, Qnil); \
1836 if (NILP (end_marker)) \
1837 end_marker = Fcopy_marker (end, Qnil);
1839 #define FETCH_START \
1840 (! NILP (start_marker) ? Fmarker_position (start_marker) : start)
1843 (! NILP (end_marker) ? Fmarker_position (end_marker) : end)
1845 /* Signal a change to the buffer immediately before it happens.
1846 START_INT and END_INT are the bounds of the text to be changed.
1848 If PRESERVE_PTR is nonzero, we relocate *PRESERVE_PTR
1849 by holding its value temporarily in a marker. */
1852 signal_before_change (start_int
, end_int
, preserve_ptr
)
1853 int start_int
, end_int
;
1856 Lisp_Object start
, end
;
1857 Lisp_Object start_marker
, end_marker
;
1858 Lisp_Object preserve_marker
;
1859 struct gcpro gcpro1
, gcpro2
, gcpro3
;
1861 if (inhibit_modification_hooks
)
1864 start
= make_number (start_int
);
1865 end
= make_number (end_int
);
1866 preserve_marker
= Qnil
;
1867 start_marker
= Qnil
;
1869 GCPRO3 (preserve_marker
, start_marker
, end_marker
);
1871 /* If buffer is unmodified, run a special hook for that case. */
1872 if (SAVE_MODIFF
>= MODIFF
1873 && !NILP (Vfirst_change_hook
)
1874 && !NILP (Vrun_hooks
))
1878 call1 (Vrun_hooks
, Qfirst_change_hook
);
1881 /* Run the before-change-function if any.
1882 We don't bother "binding" this variable to nil
1883 because it is obsolete anyway and new code should not use it. */
1884 if (!NILP (Vbefore_change_function
))
1888 call2 (Vbefore_change_function
, FETCH_START
, FETCH_END
);
1891 /* Now run the before-change-functions if any. */
1892 if (!NILP (Vbefore_change_functions
))
1894 Lisp_Object args
[3];
1895 Lisp_Object before_change_functions
;
1896 Lisp_Object after_change_functions
;
1897 struct gcpro gcpro1
, gcpro2
;
1902 /* "Bind" before-change-functions and after-change-functions
1903 to nil--but in a way that errors don't know about.
1904 That way, if there's an error in them, they will stay nil. */
1905 before_change_functions
= Vbefore_change_functions
;
1906 after_change_functions
= Vafter_change_functions
;
1907 Vbefore_change_functions
= Qnil
;
1908 Vafter_change_functions
= Qnil
;
1909 GCPRO2 (before_change_functions
, after_change_functions
);
1911 /* Actually run the hook functions. */
1912 args
[0] = Qbefore_change_functions
;
1913 args
[1] = FETCH_START
;
1914 args
[2] = FETCH_END
;
1915 run_hook_list_with_args (before_change_functions
, 3, args
);
1917 /* "Unbind" the variables we "bound" to nil. */
1918 Vbefore_change_functions
= before_change_functions
;
1919 Vafter_change_functions
= after_change_functions
;
1923 if (!NILP (current_buffer
->overlays_before
)
1924 || !NILP (current_buffer
->overlays_after
))
1927 report_overlay_modification (FETCH_START
, FETCH_END
, 0,
1928 FETCH_START
, FETCH_END
, Qnil
);
1931 if (! NILP (start_marker
))
1932 free_marker (start_marker
);
1933 if (! NILP (end_marker
))
1934 free_marker (end_marker
);
1939 /* Signal a change immediately after it happens.
1940 CHARPOS is the character position of the start of the changed text.
1941 LENDEL is the number of characters of the text before the change.
1942 (Not the whole buffer; just the part that was changed.)
1943 LENINS is the number of characters in that part of the text
1944 after the change. */
1947 signal_after_change (charpos
, lendel
, lenins
)
1948 int charpos
, lendel
, lenins
;
1950 if (inhibit_modification_hooks
)
1953 /* If we are deferring calls to the after-change functions
1954 and there are no before-change functions,
1955 just record the args that we were going to use. */
1956 if (! NILP (Vcombine_after_change_calls
)
1957 && NILP (Vbefore_change_function
) && NILP (Vbefore_change_functions
)
1958 && NILP (current_buffer
->overlays_before
)
1959 && NILP (current_buffer
->overlays_after
))
1963 if (!NILP (combine_after_change_list
)
1964 && current_buffer
!= XBUFFER (combine_after_change_buffer
))
1965 Fcombine_after_change_execute ();
1967 elt
= Fcons (make_number (charpos
- BEG
),
1968 Fcons (make_number (Z
- (charpos
- lendel
+ lenins
)),
1969 Fcons (make_number (lenins
- lendel
), Qnil
)));
1970 combine_after_change_list
1971 = Fcons (elt
, combine_after_change_list
);
1972 combine_after_change_buffer
= Fcurrent_buffer ();
1977 if (!NILP (combine_after_change_list
))
1978 Fcombine_after_change_execute ();
1980 /* Run the after-change-function if any.
1981 We don't bother "binding" this variable to nil
1982 because it is obsolete anyway and new code should not use it. */
1983 if (!NILP (Vafter_change_function
))
1984 call3 (Vafter_change_function
,
1985 make_number (charpos
), make_number (charpos
+ lenins
),
1986 make_number (lendel
));
1988 if (!NILP (Vafter_change_functions
))
1990 Lisp_Object args
[4];
1991 Lisp_Object before_change_functions
;
1992 Lisp_Object after_change_functions
;
1993 struct gcpro gcpro1
, gcpro2
;
1995 /* "Bind" before-change-functions and after-change-functions
1996 to nil--but in a way that errors don't know about.
1997 That way, if there's an error in them, they will stay nil. */
1998 before_change_functions
= Vbefore_change_functions
;
1999 after_change_functions
= Vafter_change_functions
;
2000 Vbefore_change_functions
= Qnil
;
2001 Vafter_change_functions
= Qnil
;
2002 GCPRO2 (before_change_functions
, after_change_functions
);
2004 /* Actually run the hook functions. */
2005 args
[0] = Qafter_change_functions
;
2006 XSETFASTINT (args
[1], charpos
);
2007 XSETFASTINT (args
[2], charpos
+ lenins
);
2008 XSETFASTINT (args
[3], lendel
);
2009 run_hook_list_with_args (after_change_functions
,
2012 /* "Unbind" the variables we "bound" to nil. */
2013 Vbefore_change_functions
= before_change_functions
;
2014 Vafter_change_functions
= after_change_functions
;
2018 if (!NILP (current_buffer
->overlays_before
)
2019 || !NILP (current_buffer
->overlays_after
))
2020 report_overlay_modification (make_number (charpos
),
2021 make_number (charpos
+ lenins
),
2023 make_number (charpos
),
2024 make_number (charpos
+ lenins
),
2025 make_number (lendel
));
2027 /* After an insertion, call the text properties
2028 insert-behind-hooks or insert-in-front-hooks. */
2030 report_interval_modification (make_number (charpos
),
2031 make_number (charpos
+ lenins
));
2035 Fcombine_after_change_execute_1 (val
)
2038 Vcombine_after_change_calls
= val
;
2042 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute
,
2043 Scombine_after_change_execute
, 0, 0, 0,
2044 "This function is for use internally in `combine-after-change-calls'.")
2047 int count
= specpdl_ptr
- specpdl
;
2048 int beg
, end
, change
;
2052 if (NILP (combine_after_change_list
))
2055 record_unwind_protect (Fset_buffer
, Fcurrent_buffer ());
2057 Fset_buffer (combine_after_change_buffer
);
2059 /* # chars unchanged at beginning of buffer. */
2061 /* # chars unchanged at end of buffer. */
2063 /* Total amount of insertion (negative for deletion). */
2066 /* Scan the various individual changes,
2067 accumulating the range info in BEG, END and CHANGE. */
2068 for (tail
= combine_after_change_list
; CONSP (tail
);
2072 int thisbeg
, thisend
, thischange
;
2074 /* Extract the info from the next element. */
2078 thisbeg
= XINT (XCAR (elt
));
2083 thisend
= XINT (XCAR (elt
));
2088 thischange
= XINT (XCAR (elt
));
2090 /* Merge this range into the accumulated range. */
2091 change
+= thischange
;
2098 /* Get the current start and end positions of the range
2099 that was changed. */
2103 /* We are about to handle these, so discard them. */
2104 combine_after_change_list
= Qnil
;
2106 /* Now run the after-change functions for real.
2107 Turn off the flag that defers them. */
2108 record_unwind_protect (Fcombine_after_change_execute_1
,
2109 Vcombine_after_change_calls
);
2110 signal_after_change (begpos
, endpos
- begpos
- change
, endpos
- begpos
);
2111 update_compositions (begpos
, endpos
, CHECK_ALL
);
2113 return unbind_to (count
, Qnil
);
2119 staticpro (&combine_after_change_list
);
2120 combine_after_change_list
= Qnil
;
2121 combine_after_change_buffer
= Qnil
;
2123 DEFVAR_BOOL ("check-markers-debug-flag", &check_markers_debug_flag
,
2124 "Non-nil means enable debugging checks for invalid marker positions.");
2125 check_markers_debug_flag
= 0;
2126 DEFVAR_LISP ("combine-after-change-calls", &Vcombine_after_change_calls
,
2127 "Used internally by the `combine-after-change-calls' macro.");
2128 Vcombine_after_change_calls
= Qnil
;
2130 DEFVAR_BOOL ("inhibit-modification-hooks", &inhibit_modification_hooks
,
2131 "Non-nil means don't run any of the hooks that respond to buffer changes.\n\
2132 This affects `before-change-functions' and `after-change-functions',\n\
2133 as well as hooks attached to text properties and overlays.");
2134 inhibit_modification_hooks
= 0;
2136 defsubr (&Scombine_after_change_execute
);