1 /* Buffer insertion/deletion and gap motion for XEmacs.
2 Copyright (C) 1985, 1986, 1991, 1992, 1993, 1994, 1995
3 Free Software Foundation, Inc.
4 Copyright (C) 1995 Sun Microsystems, Inc.
6 This file is part of XEmacs.
8 XEmacs is free software; you can redistribute it and/or modify it
9 under the terms of the GNU General Public License as published by the
10 Free Software Foundation; either version 2, or (at your option) any
13 XEmacs is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with XEmacs; see the file COPYING. If not, write to
20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* Synched up with: Mule 2.0, FSF 19.30. Diverges significantly. */
25 /* This file has been Mule-ized. */
27 /* Overhauled by Ben Wing, December 1994, for Mule implementation. */
30 There are three possible ways to specify positions in a buffer. All
31 of these are one-based: the beginning of the buffer is position or
32 index 1, and 0 is not a valid position.
34 As a "buffer position" (typedef Bufpos):
36 This is an index specifying an offset in characters from the
37 beginning of the buffer. Note that buffer positions are
38 logically *between* characters, not on a character. The
39 difference between two buffer positions specifies the number of
40 characters between those positions. Buffer positions are the
41 only kind of position externally visible to the user.
43 As a "byte index" (typedef Bytind):
45 This is an index over the bytes used to represent the characters
46 in the buffer. If there is no Mule support, this is identical
47 to a buffer position, because each character is represented
48 using one byte. However, with Mule support, many characters
49 require two or more bytes for their representation, and so a
50 byte index may be greater than the corresponding buffer
53 As a "memory index" (typedef Memind):
55 This is the byte index adjusted for the gap. For positions
56 before the gap, this is identical to the byte index. For
57 positions after the gap, this is the byte index plus the gap
58 size. There are two possible memory indices for the gap
59 position; the memory index at the beginning of the gap should
60 always be used, except in code that deals with manipulating the
61 gap, where both indices may be seen. The address of the
62 character "at" (i.e. following) a particular position can be
63 obtained from the formula
65 buffer_start_address + memory_index(position) - 1
67 except in the case of characters at the gap position.
74 This typedef represents a single Emacs character, which can be
75 ASCII, ISO-8859, or some extended character, as would typically
76 be used for Kanji. Note that the representation of a character
77 as an Emchar is *not* the same as the representation of that
78 same character in a string; thus, you cannot do the standard
79 C trick of passing a pointer to a character to a function that
82 An Emchar takes up 19 bits of representation and (for code
83 compatibility and such) is compatible with an int. This
84 representation is visible on the Lisp level. The important
85 characteristics of the Emchar representation are
87 -- values 0x00 - 0x7f represent ASCII.
88 -- values 0x80 - 0xff represent the right half of ISO-8859-1.
89 -- values 0x100 and up represent all other characters.
91 This means that Emchar values are upwardly compatible with
92 the standard 8-bit representation of ASCII/ISO-8859-1.
96 The data in a buffer or string is logically made up of Bufbyte
97 objects, where a Bufbyte takes up the same amount of space as a
98 char. (It is declared differently, though, to catch invalid
99 usages.) Strings stored using Bufbytes are said to be in
100 "internal format". The important characteristics of internal
103 -- ASCII characters are represented as a single Bufbyte,
104 in the range 0 - 0x7f.
105 -- All other characters are represented as a Bufbyte in
106 the range 0x80 - 0x9f followed by one or more Bufbytes
107 in the range 0xa0 to 0xff.
109 This leads to a number of desirable properties:
111 -- Given the position of the beginning of a character,
112 you can find the beginning of the next or previous
113 character in constant time.
114 -- When searching for a substring or an ASCII character
115 within the string, you need merely use standard
120 Strings that go in or out of Emacs are in "external format",
121 typedef'ed as an array of char or a char *. There is more
122 than one external format (JIS, EUC, etc.) but they all
123 have similar properties. They are modal encodings,
124 which is to say that the meaning of particular bytes is
125 not fixed but depends on what "mode" the string is currently
126 in (e.g. bytes in the range 0 - 0x7f might be
127 interpreted as ASCII, or as Hiragana, or as 2-byte Kanji,
128 depending on the current mode). The mode starts out in
129 ASCII/ISO-8859-1 and is switched using escape sequences --
130 for example, in the JIS encoding, 'ESC $ B' switches to a
131 mode where pairs of bytes in the range 0 - 0x7f
132 are interpreted as Kanji characters.
134 External-formatted data is generally desirable for passing
135 data between programs because it is upwardly compatible
136 with standard ASCII/ISO-8859-1 strings and may require
137 less space than internal encodings such as the one
138 described above. In addition, some encodings (e.g. JIS)
139 keep all characters (except the ESC used to switch modes)
140 in the printing ASCII range 0x20 - 0x7e, which results in
141 a much higher probability that the data will avoid being
142 garbled in transmission. Externally-formatted data is
143 generally not very convenient to work with, however, and
144 for this reason is usually converted to internal format
145 before any work is done on the string.
147 NOTE: filenames need to be in external format so that
148 ISO-8859-1 characters come out correctly.
152 This typedef represents a count of characters, such as
153 a character offset into a string or the number of
154 characters between two positions in a buffer. The
155 difference between two Bufpos's is a Charcount, and
156 character positions in a string are represented using
161 Similar to a Charcount but represents a count of bytes.
162 The difference between two Bytind's is a Bytecount.
165 Usage of the various representations:
166 =====================================
168 Memory indices are used in low-level functions in insdel.c and for
169 extent endpoints and marker positions. The reason for this is that
170 this way, the extents and markers don't need to be updated for most
171 insertions, which merely shrink the gap and don't move any
172 characters around in memory.
174 (The beginning-of-gap memory index simplifies insertions w.r.t.
175 markers, because text usually gets inserted after markers. For
176 extents, it is merely for consistency, because text can get
177 inserted either before or after an extent's endpoint depending on
178 the open/closedness of the endpoint.)
180 Byte indices are used in other code that needs to be fast,
181 such as the searching, redisplay, and extent-manipulation code.
183 Buffer positions are used in all other code. This is because this
184 representation is easiest to work with (especially since Lisp
185 code always uses buffer positions), necessitates the fewest
186 changes to existing code, and is the safest (e.g. if the text gets
187 shifted underneath a buffer position, it will still point to a
188 character; if text is shifted under a byte index, it might point
189 to the middle of a character, which would be bad).
191 Similarly, Charcounts are used in all code that deals with strings
192 except for code that needs to be fast, which used Bytecounts.
194 Strings are always passed around internally using internal format.
195 Conversions between external format are performed at the time
196 that the data goes in or out of Emacs.
198 Working with the various representations:
199 ========================================= */
211 #include "redisplay.h"
212 #include "line-number.h"
214 /* We write things this way because it's very important the
215 MAX_BYTIND_GAP_SIZE_3 is a multiple of 3. (As it happens,
216 65535 is a multiple of 3, but this may not always be the
219 #define MAX_BUFPOS_GAP_SIZE_3 (65535/3)
220 #define MAX_BYTIND_GAP_SIZE_3 (3 * MAX_BUFPOS_GAP_SIZE_3)
223 short three_to_one_table[1 + MAX_BYTIND_GAP_SIZE_3];
226 /* Various macros modelled along the lines of those in buffer.h.
227 Purposefully omitted from buffer.h because files other than this
228 one should not be using them. */
230 /* Address of beginning of buffer. This is an lvalue because
231 BUFFER_ALLOC needs it to be. */
232 #define BUF_BEG_ADDR(buf) ((buf)->text->beg)
234 /* Set the address of beginning of buffer. */
235 #define SET_BUF_BEG_ADDR(buf, addr) do { (buf)->text->beg = (addr); } while (0)
238 #define BUF_GAP_SIZE(buf) ((buf)->text->gap_size + 0)
239 #define BUF_END_GAP_SIZE(buf) ((buf)->text->end_gap_size + 0)
241 #define SET_BUF_GAP_SIZE(buf, value) \
242 do { (buf)->text->gap_size = (value); } while (0)
243 #define SET_BUF_END_GAP_SIZE(buf, value) \
244 do { (buf)->text->end_gap_size = (value); } while (0)
247 #define BI_BUF_GPT(buf) ((buf)->text->gpt + 0)
248 #define BUF_GPT_ADDR(buf) (BUF_BEG_ADDR (buf) + BI_BUF_GPT (buf) - 1)
250 /* Set gap location. */
251 #define SET_BI_BUF_GPT(buf, value) do { (buf)->text->gpt = (value); } while (0)
253 /* Set end of buffer. */
254 #define SET_BOTH_BUF_Z(buf, val, bival) \
257 (buf)->text->z = (bival); \
258 (buf)->text->bufz = (val); \
261 /* Under Mule, we maintain two sentinels in the buffer: one at the
262 beginning of the gap, and one at the end of the buffer. This
263 allows us to move forward, examining bytes looking for the
264 end of a character, and not worry about running off the end.
265 We do not need corresponding sentinels when moving backwards
266 because we do not have to look past the beginning of a character
267 to find the beginning of the character.
269 Every time we change the beginning of the gap, we have to
270 call SET_GAP_SENTINEL().
272 Every time we change the total size (characters plus gap)
273 of the buffer, we have to call SET_END_SENTINEL().
278 # define GAP_CAN_HOLD_SIZE_P(buf, len) (BUF_GAP_SIZE (buf) >= (len) + 1)
279 # define SET_GAP_SENTINEL(buf) (*BUF_GPT_ADDR (buf) = 0)
280 # define BUF_END_SENTINEL_SIZE 1
281 # define SET_END_SENTINEL(buf) \
282 (*(BUF_BEG_ADDR (buf) + BUF_GAP_SIZE (buf) + BI_BUF_Z (buf) - 1) = 0)
284 # define GAP_CAN_HOLD_SIZE_P(buf, len) (BUF_GAP_SIZE (buf) >= (len))
285 # define SET_GAP_SENTINEL(buf)
286 # define BUF_END_SENTINEL_SIZE 0
287 # define SET_END_SENTINEL(buf)
291 /************************************************************************/
292 /* Charcount/Bytecount conversion */
293 /************************************************************************/
295 /* Optimization. Do it. Live it. Love it. */
299 /* We include the basic functions here that require no specific
300 knowledge of how data is Mule-encoded into a buffer other
301 than the basic (00 - 7F), (80 - 9F), (A0 - FF) scheme.
302 Anything that requires more specific knowledge goes into
305 /* Given a pointer to a text string and a length in bytes, return
306 the equivalent length in characters. */
309 bytecount_to_charcount (CONST Bufbyte *ptr, Bytecount len)
312 CONST Bufbyte *end = ptr + len;
314 #if (LONGBITS == 32 || LONGBITS == 64)
316 # if (LONGBITS == 32)
317 # define LONG_BYTES 4
318 # define ALIGN_MASK 0xFFFFFFFCU
319 # define HIGH_BIT_MASK 0x80808080U
321 # define LONG_BYTES 8
322 # define ALIGN_MASK 0xFFFFFFFFFFFFFFF8UL
323 /* I had a dream, I was being overrun with early Intel processors ... */
324 # define HIGH_BIT_MASK 0x8080808080808080UL
327 /* When we have a large number of bytes to scan, we can be trickier
328 and significantly faster by scanning them in chunks of the CPU word
329 size (assuming that they're all ASCII -- we cut out as soon as
330 we find something non-ASCII). */
333 /* Determine the section in the middle of the string that's
334 amenable to this treatment. Everything has to be aligned
335 on CPU word boundaries. */
336 CONST Bufbyte *aligned_ptr =
337 (CONST Bufbyte *) (((unsigned long) (ptr + LONG_BYTES - 1)) &
339 CONST Bufbyte *aligned_end =
340 (CONST Bufbyte *) (((unsigned long) end) & ALIGN_MASK);
342 /* Handle unaligned stuff at the beginning. */
343 while (ptr < aligned_ptr)
345 if (!BYTE_ASCII_P (*ptr))
350 while (ptr < aligned_end)
353 if ((* (unsigned long *) ptr) & HIGH_BIT_MASK)
360 #endif /* LONGBITS == 32 || LONGBITS == 64 */
368 #ifdef ERROR_CHECK_BUFPOS
369 /* Bomb out if the specified substring ends in the middle
370 of a character. Note that we might have already gotten
371 a core dump above from an invalid reference, but at least
372 we will get no farther than here. */
379 /* Given a pointer to a text string and a length in characters, return
380 the equivalent length in bytes. */
383 charcount_to_bytecount (CONST Bufbyte *ptr, Charcount len)
385 CONST Bufbyte *newptr = ptr;
389 INC_CHARPTR (newptr);
395 /* The next two functions are the actual meat behind the
396 bufpos-to-bytind and bytind-to-bufpos conversions. Currently
397 the method they use is fairly unsophisticated; see buffer.h.
399 Note that bufpos_to_bytind_func() is probably the most-called
400 function in all of XEmacs. Therefore, it must be FAST FAST FAST.
401 This is the reason why so much of the code is duplicated.
403 Similar considerations apply to bytind_to_bufpos_func(), although
404 less so because the function is not called so often.
406 #### At some point this should use a more sophisticated method;
409 static int not_very_random_number;
412 bufpos_to_bytind_func (struct buffer *buf, Bufpos x)
422 int add_to_cache = 0;
424 /* Check for some cached positions, for speed. */
425 if (x == BUF_PT (buf))
426 return BI_BUF_PT (buf);
427 if (x == BUF_ZV (buf))
428 return BI_BUF_ZV (buf);
429 if (x == BUF_BEGV (buf))
430 return BI_BUF_BEGV (buf);
432 bufmin = buf->text->mule_bufmin;
433 bufmax = buf->text->mule_bufmax;
434 bytmin = buf->text->mule_bytmin;
435 bytmax = buf->text->mule_bytmax;
437 size = buf->text->mule_size;
439 size = (1 << buf->text->mule_shifter) + !!buf->text->mule_three_p;
442 /* The basic idea here is that we shift the "known region" up or down
443 until it overlaps the specified position. We do this by moving
444 the upper bound of the known region up one character at a time,
445 and moving the lower bound of the known region up as necessary
446 when the size of the character just seen changes.
448 We optimize this, however, by first shifting the known region to
449 one of the cached points if it's close by. (We don't check BEG or
450 Z, even though they're cached; most of the time these will be the
451 same as BEGV and ZV, and when they're not, they're not likely
456 Bufpos diffmax = x - bufmax;
457 Bufpos diffpt = x - BUF_PT (buf);
458 Bufpos diffzv = BUF_ZV (buf) - x;
459 /* #### This value could stand some more exploration. */
460 Charcount heuristic_hack = (bufmax - bufmin) >> 2;
462 /* Check if the position is closer to PT or ZV than to the
463 end of the known region. */
470 /* But also implement a heuristic that favors the known region
471 over PT or ZV. The reason for this is that switching to
472 PT or ZV will wipe out the knowledge in the known region,
473 which might be annoying if the known region is large and
474 PT or ZV is not that much closer than the end of the known
477 diffzv += heuristic_hack;
478 diffpt += heuristic_hack;
479 if (diffpt < diffmax && diffpt <= diffzv)
481 bufmax = bufmin = BUF_PT (buf);
482 bytmax = bytmin = BI_BUF_PT (buf);
483 /* We set the size to 1 even though it doesn't really
484 matter because the new known region contains no
485 characters. We do this because this is the most
486 likely size of the characters around the new known
487 region, and we avoid potential yuckiness that is
488 done when size == 3. */
491 if (diffzv < diffmax)
493 bufmax = bufmin = BUF_ZV (buf);
494 bytmax = bytmin = BI_BUF_ZV (buf);
498 #ifdef ERROR_CHECK_BUFPOS
499 else if (x >= bufmin)
504 Bufpos diffmin = bufmin - x;
505 Bufpos diffpt = BUF_PT (buf) - x;
506 Bufpos diffbegv = x - BUF_BEGV (buf);
507 /* #### This value could stand some more exploration. */
508 Charcount heuristic_hack = (bufmax - bufmin) >> 2;
513 diffbegv = -diffbegv;
515 /* But also implement a heuristic that favors the known region --
518 diffbegv += heuristic_hack;
519 diffpt += heuristic_hack;
521 if (diffpt < diffmin && diffpt <= diffbegv)
523 bufmax = bufmin = BUF_PT (buf);
524 bytmax = bytmin = BI_BUF_PT (buf);
525 /* We set the size to 1 even though it doesn't really
526 matter because the new known region contains no
527 characters. We do this because this is the most
528 likely size of the characters around the new known
529 region, and we avoid potential yuckiness that is
530 done when size == 3. */
533 if (diffbegv < diffmin)
535 bufmax = bufmin = BUF_BEGV (buf);
536 bytmax = bytmin = BI_BUF_BEGV (buf);
541 diff_so_far = x > bufmax ? x - bufmax : bufmin - x;
542 if (diff_so_far > 50)
544 /* If we have to move more than a certain amount, then look
546 int minval = INT_MAX;
551 /* I considered keeping the positions ordered. This would speed
552 up this loop, but updating the cache would take longer, so
553 it doesn't seem like it would really matter. */
554 for (i = 0; i < 16; i++)
556 int diff = buf->text->mule_bufpos_cache[i] - x;
567 if (minval < diff_so_far)
569 bufmax = bufmin = buf->text->mule_bufpos_cache[found];
570 bytmax = bytmin = buf->text->mule_bytind_cache[found];
575 /* It's conceivable that the caching above could lead to X being
576 the same as one of the range edges. */
587 INC_BYTIND (buf, newmax);
588 newsize = newmax - bytmax;
600 /* #### Should go past the found location to reduce the number
601 of times that this function is called */
603 else /* x < bufmin */
613 DEC_BYTIND (buf, newmin);
614 newsize = bytmin - newmin;
626 /* #### Should go past the found location to reduce the number
627 of times that this function is called
631 /* If size is three, than we have to max sure that the range we
632 discovered isn't too large, because we use a fixed-length
633 table to divide by 3. */
636 buf->text->mule_size = size;
640 int gap = bytmax - bytmin;
642 buf->text->mule_three_p = 1;
643 buf->text->mule_shifter = 1;
646 if (gap > MAX_BYTIND_GAP_SIZE_3)
650 bytmin = bytmax - MAX_BYTIND_GAP_SIZE_3;
651 bufmin = bufmax - MAX_BUFPOS_GAP_SIZE_3;
655 bytmax = bytmin + MAX_BYTIND_GAP_SIZE_3;
656 bufmax = bufmin + MAX_BUFPOS_GAP_SIZE_3;
663 buf->text->mule_three_p = 0;
665 buf->text->mule_shifter = 2;
667 buf->text->mule_shifter = size - 1;
671 buf->text->mule_bufmin = bufmin;
672 buf->text->mule_bufmax = bufmax;
673 buf->text->mule_bytmin = bytmin;
674 buf->text->mule_bytmax = bytmax;
680 /* We throw away a "random" cached value and replace it with
681 the new value. It doesn't actually have to be very random
682 at all, just evenly distributed.
684 #### It would be better to use a least-recently-used algorithm
685 or something that tries to space things out, but I'm not sure
686 it's worth it to go to the trouble of maintaining that. */
687 not_very_random_number += 621;
688 replace_loc = not_very_random_number & 15;
689 buf->text->mule_bufpos_cache[replace_loc] = x;
690 buf->text->mule_bytind_cache[replace_loc] = retval;
696 /* The logic in this function is almost identical to the logic in
697 the previous function. */
700 bytind_to_bufpos_func (struct buffer *buf, Bytind x)
710 int add_to_cache = 0;
712 /* Check for some cached positions, for speed. */
713 if (x == BI_BUF_PT (buf))
715 if (x == BI_BUF_ZV (buf))
717 if (x == BI_BUF_BEGV (buf))
718 return BUF_BEGV (buf);
720 bufmin = buf->text->mule_bufmin;
721 bufmax = buf->text->mule_bufmax;
722 bytmin = buf->text->mule_bytmin;
723 bytmax = buf->text->mule_bytmax;
725 size = buf->text->mule_size;
727 size = (1 << buf->text->mule_shifter) + !!buf->text->mule_three_p;
730 /* The basic idea here is that we shift the "known region" up or down
731 until it overlaps the specified position. We do this by moving
732 the upper bound of the known region up one character at a time,
733 and moving the lower bound of the known region up as necessary
734 when the size of the character just seen changes.
736 We optimize this, however, by first shifting the known region to
737 one of the cached points if it's close by. (We don't check BI_BEG or
738 BI_Z, even though they're cached; most of the time these will be the
739 same as BI_BEGV and BI_ZV, and when they're not, they're not likely
744 Bytind diffmax = x - bytmax;
745 Bytind diffpt = x - BI_BUF_PT (buf);
746 Bytind diffzv = BI_BUF_ZV (buf) - x;
747 /* #### This value could stand some more exploration. */
748 Bytecount heuristic_hack = (bytmax - bytmin) >> 2;
750 /* Check if the position is closer to PT or ZV than to the
751 end of the known region. */
758 /* But also implement a heuristic that favors the known region
759 over BI_PT or BI_ZV. The reason for this is that switching to
760 BI_PT or BI_ZV will wipe out the knowledge in the known region,
761 which might be annoying if the known region is large and
762 BI_PT or BI_ZV is not that much closer than the end of the known
765 diffzv += heuristic_hack;
766 diffpt += heuristic_hack;
767 if (diffpt < diffmax && diffpt <= diffzv)
769 bufmax = bufmin = BUF_PT (buf);
770 bytmax = bytmin = BI_BUF_PT (buf);
771 /* We set the size to 1 even though it doesn't really
772 matter because the new known region contains no
773 characters. We do this because this is the most
774 likely size of the characters around the new known
775 region, and we avoid potential yuckiness that is
776 done when size == 3. */
779 if (diffzv < diffmax)
781 bufmax = bufmin = BUF_ZV (buf);
782 bytmax = bytmin = BI_BUF_ZV (buf);
786 #ifdef ERROR_CHECK_BUFPOS
787 else if (x >= bytmin)
792 Bytind diffmin = bytmin - x;
793 Bytind diffpt = BI_BUF_PT (buf) - x;
794 Bytind diffbegv = x - BI_BUF_BEGV (buf);
795 /* #### This value could stand some more exploration. */
796 Bytecount heuristic_hack = (bytmax - bytmin) >> 2;
801 diffbegv = -diffbegv;
803 /* But also implement a heuristic that favors the known region --
806 diffbegv += heuristic_hack;
807 diffpt += heuristic_hack;
809 if (diffpt < diffmin && diffpt <= diffbegv)
811 bufmax = bufmin = BUF_PT (buf);
812 bytmax = bytmin = BI_BUF_PT (buf);
813 /* We set the size to 1 even though it doesn't really
814 matter because the new known region contains no
815 characters. We do this because this is the most
816 likely size of the characters around the new known
817 region, and we avoid potential yuckiness that is
818 done when size == 3. */
821 if (diffbegv < diffmin)
823 bufmax = bufmin = BUF_BEGV (buf);
824 bytmax = bytmin = BI_BUF_BEGV (buf);
829 diff_so_far = x > bytmax ? x - bytmax : bytmin - x;
830 if (diff_so_far > 50)
832 /* If we have to move more than a certain amount, then look
834 int minval = INT_MAX;
839 /* I considered keeping the positions ordered. This would speed
840 up this loop, but updating the cache would take longer, so
841 it doesn't seem like it would really matter. */
842 for (i = 0; i < 16; i++)
844 int diff = buf->text->mule_bytind_cache[i] - x;
855 if (minval < diff_so_far)
857 bufmax = bufmin = buf->text->mule_bufpos_cache[found];
858 bytmax = bytmin = buf->text->mule_bytind_cache[found];
863 /* It's conceivable that the caching above could lead to X being
864 the same as one of the range edges. */
875 INC_BYTIND (buf, newmax);
876 newsize = newmax - bytmax;
888 /* #### Should go past the found location to reduce the number
889 of times that this function is called */
891 else /* x <= bytmin */
901 DEC_BYTIND (buf, newmin);
902 newsize = bytmin - newmin;
914 /* #### Should go past the found location to reduce the number
915 of times that this function is called
919 /* If size is three, than we have to max sure that the range we
920 discovered isn't too large, because we use a fixed-length
921 table to divide by 3. */
924 buf->text->mule_size = size;
928 int gap = bytmax - bytmin;
930 buf->text->mule_three_p = 1;
931 buf->text->mule_shifter = 1;
934 if (gap > MAX_BYTIND_GAP_SIZE_3)
938 bytmin = bytmax - MAX_BYTIND_GAP_SIZE_3;
939 bufmin = bufmax - MAX_BUFPOS_GAP_SIZE_3;
943 bytmax = bytmin + MAX_BYTIND_GAP_SIZE_3;
944 bufmax = bufmin + MAX_BUFPOS_GAP_SIZE_3;
951 buf->text->mule_three_p = 0;
953 buf->text->mule_shifter = 2;
955 buf->text->mule_shifter = size - 1;
959 buf->text->mule_bufmin = bufmin;
960 buf->text->mule_bufmax = bufmax;
961 buf->text->mule_bytmin = bytmin;
962 buf->text->mule_bytmax = bytmax;
968 /* We throw away a "random" cached value and replace it with
969 the new value. It doesn't actually have to be very random
970 at all, just evenly distributed.
972 #### It would be better to use a least-recently-used algorithm
973 or something that tries to space things out, but I'm not sure
974 it's worth it to go to the trouble of maintaining that. */
975 not_very_random_number += 621;
976 replace_loc = not_very_random_number & 15;
977 buf->text->mule_bufpos_cache[replace_loc] = retval;
978 buf->text->mule_bytind_cache[replace_loc] = x;
984 /* Text of length BYTELENGTH and CHARLENGTH (in different units)
985 was inserted at bufpos START. */
988 buffer_mule_signal_inserted_region (struct buffer *buf, Bufpos start,
989 Bytecount bytelength,
990 Charcount charlength)
993 int size = buf->text->mule_size;
995 int size = (1 << buf->text->mule_shifter) + !!buf->text->mule_three_p;
999 /* Adjust the cache of known positions. */
1000 for (i = 0; i < 16; i++)
1003 if (buf->text->mule_bufpos_cache[i] > start)
1005 buf->text->mule_bufpos_cache[i] += charlength;
1006 buf->text->mule_bytind_cache[i] += bytelength;
1010 if (start >= buf->text->mule_bufmax)
1013 /* The insertion is either before the known region, in which case
1014 it shoves it forward; or within the known region, in which case
1015 it shoves the end forward. (But it may make the known region
1016 inconsistent, so we may have to shorten it.) */
1018 if (start <= buf->text->mule_bufmin)
1020 buf->text->mule_bufmin += charlength;
1021 buf->text->mule_bufmax += charlength;
1022 buf->text->mule_bytmin += bytelength;
1023 buf->text->mule_bytmax += bytelength;
1027 Bufpos end = start + charlength;
1028 /* the insertion point divides the known region in two.
1029 Keep the longer half, at least, and expand into the
1030 inserted chunk as much as possible. */
1032 if (start - buf->text->mule_bufmin > buf->text->mule_bufmax - start)
1034 Bytind bytestart = (buf->text->mule_bytmin
1035 + size * (start - buf->text->mule_bufmin));
1040 bytenew = bytestart;
1041 INC_BYTIND (buf, bytenew);
1042 if (bytenew - bytestart != size)
1045 bytestart = bytenew;
1049 buf->text->mule_bufmax = start;
1050 buf->text->mule_bytmax = bytestart;
1054 buf->text->mule_bufmax += charlength;
1055 buf->text->mule_bytmax += bytelength;
1060 Bytind byteend = (buf->text->mule_bytmin
1061 + size * (start - buf->text->mule_bufmin)
1065 buf->text->mule_bufmax += charlength;
1066 buf->text->mule_bytmax += bytelength;
1071 DEC_BYTIND (buf, bytenew);
1072 if (byteend - bytenew != size)
1079 buf->text->mule_bufmin = end;
1080 buf->text->mule_bytmin = byteend;
1086 /* Text from START to END (equivalent in Bytinds: from BI_START to
1087 BI_END) was deleted. */
1090 buffer_mule_signal_deleted_region (struct buffer *buf, Bufpos start,
1091 Bufpos end, Bytind bi_start,
1096 /* Adjust the cache of known positions. */
1097 for (i = 0; i < 16; i++)
1099 /* After the end; gets shoved backward */
1100 if (buf->text->mule_bufpos_cache[i] > end)
1102 buf->text->mule_bufpos_cache[i] -= end - start;
1103 buf->text->mule_bytind_cache[i] -= bi_end - bi_start;
1105 /* In the range; moves to start of range */
1106 else if (buf->text->mule_bufpos_cache[i] > start)
1108 buf->text->mule_bufpos_cache[i] = start;
1109 buf->text->mule_bytind_cache[i] = bi_start;
1113 /* We don't care about any text after the end of the known region. */
1115 end = min (end, buf->text->mule_bufmax);
1116 bi_end = min (bi_end, buf->text->mule_bytmax);
1120 /* The end of the known region offsets by the total amount of deletion,
1121 since it's all before it. */
1123 buf->text->mule_bufmax -= end - start;
1124 buf->text->mule_bytmax -= bi_end - bi_start;
1126 /* Now we don't care about any text after the start of the known region. */
1128 end = min (end, buf->text->mule_bufmin);
1129 bi_end = min (bi_end, buf->text->mule_bytmin);
1133 buf->text->mule_bufmin -= end - start;
1134 buf->text->mule_bytmin -= bi_end - bi_start;
1139 #ifdef ERROR_CHECK_BUFPOS
1142 bufpos_to_bytind (struct buffer *buf, Bufpos x)
1144 Bytind retval = real_bufpos_to_bytind (buf, x);
1145 ASSERT_VALID_BYTIND_UNSAFE (buf, retval);
1150 bytind_to_bufpos (struct buffer *buf, Bytind x)
1152 ASSERT_VALID_BYTIND_UNSAFE (buf, x);
1153 return real_bytind_to_bufpos (buf, x);
1156 #endif /* ERROR_CHECK_BUFPOS */
1159 /************************************************************************/
1160 /* verifying buffer and string positions */
1161 /************************************************************************/
1163 /* Functions below are tagged with either _byte or _char indicating
1164 whether they return byte or character positions. For a buffer,
1165 a character position is a "Bufpos" and a byte position is a "Bytind".
1166 For strings, these are sometimes typed using "Charcount" and
1169 /* Flags for the functions below are:
1171 GB_ALLOW_PAST_ACCESSIBLE
1173 Allow positions to range over the entire buffer (BUF_BEG to BUF_Z),
1174 rather than just the accessible portion (BUF_BEGV to BUF_ZV).
1175 For strings, this flag has no effect.
1179 If the position is outside the allowable range, return the lower
1180 or upper bound of the range, whichever is closer to the specified
1185 If the position is outside the allowable range, return -1.
1187 GB_NEGATIVE_FROM_END
1189 If a value is negative, treat it as an offset from the end.
1190 Only applies to strings.
1192 The following additional flags apply only to the functions
1197 Either or both positions can be nil. If FROM is nil,
1198 FROM_OUT will contain the lower bound of the allowed range.
1199 If TO is nil, TO_OUT will contain the upper bound of the
1204 FROM must contain the lower bound and TO the upper bound
1205 of the range. If the positions are reversed, an error is
1208 The following is a combination flag:
1210 GB_HISTORICAL_STRING_BEHAVIOR
1212 Equivalent to (GB_NEGATIVE_FROM_END | GB_ALLOW_NIL).
1215 /* Return a buffer position stored in a Lisp_Object. Full
1216 error-checking is done on the position. Flags can be specified to
1217 control the behavior of out-of-range values. The default behavior
1218 is to require that the position is within the accessible part of
1219 the buffer (BEGV and ZV), and to signal an error if the position is
1225 get_buffer_pos_char (struct buffer *b, Lisp_Object pos, unsigned int flags)
1228 Bufpos min_allowed, max_allowed;
1230 CHECK_INT_COERCE_MARKER (pos);
1232 min_allowed = flags & GB_ALLOW_PAST_ACCESSIBLE ? BUF_BEG (b) : BUF_BEGV (b);
1233 max_allowed = flags & GB_ALLOW_PAST_ACCESSIBLE ? BUF_Z (b) : BUF_ZV (b);
1235 if (ind < min_allowed || ind > max_allowed)
1237 if (flags & GB_COERCE_RANGE)
1238 ind = ind < min_allowed ? min_allowed : max_allowed;
1239 else if (flags & GB_NO_ERROR_IF_BAD)
1244 XSETBUFFER (buffer, b);
1245 args_out_of_range (buffer, pos);
1253 get_buffer_pos_byte (struct buffer *b, Lisp_Object pos, unsigned int flags)
1255 Bufpos bpos = get_buffer_pos_char (b, pos, flags);
1256 if (bpos < 0) /* could happen with GB_NO_ERROR_IF_BAD */
1258 return bufpos_to_bytind (b, bpos);
1261 /* Return a pair of buffer positions representing a range of text,
1262 taken from a pair of Lisp_Objects. Full error-checking is
1263 done on the positions. Flags can be specified to control the
1264 behavior of out-of-range values. The default behavior is to
1265 allow the range bounds to be specified in either order
1266 (however, FROM_OUT will always be the lower bound of the range
1267 and TO_OUT the upper bound),to require that the positions
1268 are within the accessible part of the buffer (BEGV and ZV),
1269 and to signal an error if the positions are out of range.
1273 get_buffer_range_char (struct buffer *b, Lisp_Object from, Lisp_Object to,
1274 Bufpos *from_out, Bufpos *to_out, unsigned int flags)
1276 Bufpos min_allowed, max_allowed;
1278 min_allowed = (flags & GB_ALLOW_PAST_ACCESSIBLE) ?
1279 BUF_BEG (b) : BUF_BEGV (b);
1280 max_allowed = (flags & GB_ALLOW_PAST_ACCESSIBLE) ?
1281 BUF_Z (b) : BUF_ZV (b);
1283 if (NILP (from) && (flags & GB_ALLOW_NIL))
1284 *from_out = min_allowed;
1286 *from_out = get_buffer_pos_char (b, from, flags | GB_NO_ERROR_IF_BAD);
1288 if (NILP (to) && (flags & GB_ALLOW_NIL))
1289 *to_out = max_allowed;
1291 *to_out = get_buffer_pos_char (b, to, flags | GB_NO_ERROR_IF_BAD);
1293 if ((*from_out < 0 || *to_out < 0) && !(flags & GB_NO_ERROR_IF_BAD))
1296 XSETBUFFER (buffer, b);
1297 args_out_of_range_3 (buffer, from, to);
1300 if (*from_out >= 0 && *to_out >= 0 && *from_out > *to_out)
1302 if (flags & GB_CHECK_ORDER)
1303 signal_simple_error_2 ("start greater than end", from, to);
1306 Bufpos temp = *from_out;
1307 *from_out = *to_out;
1314 get_buffer_range_byte (struct buffer *b, Lisp_Object from, Lisp_Object to,
1315 Bytind *from_out, Bytind *to_out, unsigned int flags)
1319 get_buffer_range_char (b, from, to, &s, &e, flags);
1321 *from_out = bufpos_to_bytind (b, s);
1322 else /* could happen with GB_NO_ERROR_IF_BAD */
1325 *to_out = bufpos_to_bytind (b, e);
1331 get_string_pos_char_1 (Lisp_Object string, Lisp_Object pos, unsigned int flags,
1332 Charcount known_length)
1335 Charcount min_allowed = 0;
1336 Charcount max_allowed = known_length;
1338 /* Computation of KNOWN_LENGTH is potentially expensive so we pass
1342 if (ccpos < 0 && flags & GB_NEGATIVE_FROM_END)
1343 ccpos += max_allowed;
1345 if (ccpos < min_allowed || ccpos > max_allowed)
1347 if (flags & GB_COERCE_RANGE)
1348 ccpos = ccpos < min_allowed ? min_allowed : max_allowed;
1349 else if (flags & GB_NO_ERROR_IF_BAD)
1352 args_out_of_range (string, pos);
1359 get_string_pos_char (Lisp_Object string, Lisp_Object pos, unsigned int flags)
1361 return get_string_pos_char_1 (string, pos, flags,
1362 XSTRING_CHAR_LENGTH (string));
1366 get_string_pos_byte (Lisp_Object string, Lisp_Object pos, unsigned int flags)
1368 Charcount ccpos = get_string_pos_char (string, pos, flags);
1369 if (ccpos < 0) /* could happen with GB_NO_ERROR_IF_BAD */
1371 return charcount_to_bytecount (XSTRING_DATA (string), ccpos);
1375 get_string_range_char (Lisp_Object string, Lisp_Object from, Lisp_Object to,
1376 Charcount *from_out, Charcount *to_out,
1379 Charcount min_allowed = 0;
1380 Charcount max_allowed = XSTRING_CHAR_LENGTH (string);
1382 if (NILP (from) && (flags & GB_ALLOW_NIL))
1383 *from_out = min_allowed;
1385 *from_out = get_string_pos_char_1 (string, from,
1386 flags | GB_NO_ERROR_IF_BAD,
1389 if (NILP (to) && (flags & GB_ALLOW_NIL))
1390 *to_out = max_allowed;
1392 *to_out = get_string_pos_char_1 (string, to,
1393 flags | GB_NO_ERROR_IF_BAD,
1396 if ((*from_out < 0 || *to_out < 0) && !(flags & GB_NO_ERROR_IF_BAD))
1397 args_out_of_range_3 (string, from, to);
1399 if (*from_out >= 0 && *to_out >= 0 && *from_out > *to_out)
1401 if (flags & GB_CHECK_ORDER)
1402 signal_simple_error_2 ("start greater than end", from, to);
1405 Bufpos temp = *from_out;
1406 *from_out = *to_out;
1413 get_string_range_byte (Lisp_Object string, Lisp_Object from, Lisp_Object to,
1414 Bytecount *from_out, Bytecount *to_out,
1419 get_string_range_char (string, from, to, &s, &e, flags);
1421 *from_out = charcount_to_bytecount (XSTRING_DATA (string), s);
1422 else /* could happen with GB_NO_ERROR_IF_BAD */
1425 *to_out = charcount_to_bytecount (XSTRING_DATA (string), e);
1432 get_buffer_or_string_pos_char (Lisp_Object object, Lisp_Object pos,
1435 return STRINGP (object) ?
1436 get_string_pos_char (object, pos, flags) :
1437 get_buffer_pos_char (XBUFFER (object), pos, flags);
1441 get_buffer_or_string_pos_byte (Lisp_Object object, Lisp_Object pos,
1444 return STRINGP (object) ?
1445 get_string_pos_byte (object, pos, flags) :
1446 get_buffer_pos_byte (XBUFFER (object), pos, flags);
1450 get_buffer_or_string_range_char (Lisp_Object object, Lisp_Object from,
1451 Lisp_Object to, Bufpos *from_out,
1452 Bufpos *to_out, unsigned int flags)
1454 if (STRINGP (object))
1455 get_string_range_char (object, from, to, from_out, to_out, flags);
1457 get_buffer_range_char (XBUFFER (object), from, to, from_out, to_out, flags);
1461 get_buffer_or_string_range_byte (Lisp_Object object, Lisp_Object from,
1462 Lisp_Object to, Bytind *from_out,
1463 Bytind *to_out, unsigned int flags)
1465 if (STRINGP (object))
1466 get_string_range_byte (object, from, to, from_out, to_out, flags);
1468 get_buffer_range_byte (XBUFFER (object), from, to, from_out, to_out, flags);
1472 buffer_or_string_accessible_begin_char (Lisp_Object object)
1474 return STRINGP (object) ? 0 : BUF_BEGV (XBUFFER (object));
1478 buffer_or_string_accessible_end_char (Lisp_Object object)
1480 return STRINGP (object) ?
1481 XSTRING_CHAR_LENGTH (object) : BUF_ZV (XBUFFER (object));
1485 buffer_or_string_accessible_begin_byte (Lisp_Object object)
1487 return STRINGP (object) ? 0 : BI_BUF_BEGV (XBUFFER (object));
1491 buffer_or_string_accessible_end_byte (Lisp_Object object)
1493 return STRINGP (object) ?
1494 XSTRING_LENGTH (object) : BI_BUF_ZV (XBUFFER (object));
1498 buffer_or_string_absolute_begin_char (Lisp_Object object)
1500 return STRINGP (object) ? 0 : BUF_BEG (XBUFFER (object));
1504 buffer_or_string_absolute_end_char (Lisp_Object object)
1506 return STRINGP (object) ?
1507 XSTRING_CHAR_LENGTH (object) : BUF_Z (XBUFFER (object));
1511 buffer_or_string_absolute_begin_byte (Lisp_Object object)
1513 return STRINGP (object) ? 0 : BI_BUF_BEG (XBUFFER (object));
1517 buffer_or_string_absolute_end_byte (Lisp_Object object)
1519 return STRINGP (object) ?
1520 XSTRING_LENGTH (object) : BI_BUF_Z (XBUFFER (object));
1524 /************************************************************************/
1525 /* point and marker adjustment */
1526 /************************************************************************/
1528 /* just_set_point() is the only place `PT' is an lvalue in all of emacs.
1529 This function is called from set_buffer_point(), which is the function
1530 that the SET_PT and BUF_SET_PT macros expand into, and from the
1531 routines below that insert and delete text. (This is in cases where
1532 the point marker logically doesn't move but PT (being a byte index)
1533 needs to get adjusted.) */
1535 /* Set point to a specified value. This is used only when the value
1536 of point changes due to an insert or delete; it does not represent
1537 a conceptual change in point as a marker. In particular, point is
1538 not crossing any interval boundaries, so there's no need to use the
1539 usual SET_PT macro. In fact it would be incorrect to do so, because
1540 either the old or the new value of point is out of synch with the
1541 current set of intervals. */
1543 /* This gets called more than enough to make the function call
1544 overhead a significant factor so we've turned it into a macro. */
1545 #define JUST_SET_POINT(buf, bufpos, ind) \
1548 buf->bufpt = (bufpos); \
1552 /* Set a buffer's point. */
1555 set_buffer_point (struct buffer *buf, Bufpos bufpos, Bytind bytpos)
1557 assert (bytpos >= BI_BUF_BEGV (buf) && bytpos <= BI_BUF_ZV (buf));
1558 if (bytpos == BI_BUF_PT (buf))
1560 JUST_SET_POINT (buf, bufpos, bytpos);
1562 assert (MARKERP (buf->point_marker));
1563 XMARKER (buf->point_marker)->memind =
1564 bytind_to_memind (buf, bytpos);
1566 /* FSF makes sure that PT is not being set within invisible text.
1567 However, this is the wrong place for that check. The check
1568 should happen only at the next redisplay. */
1570 /* Some old coder said:
1572 "If there were to be hooks which were run when point entered/left an
1573 extent, this would be the place to put them.
1575 However, it's probably the case that such hooks should be implemented
1576 using a post-command-hook instead, to avoid running the hooks as a
1577 result of intermediate motion inside of save-excursions, for example."
1579 I definitely agree with this. PT gets moved all over the place
1580 and it would be a Bad Thing for any hooks to get called, both for
1581 the reason above and because many callers are not prepared for
1582 a GC within this function. --ben
1586 /* Do the correct marker-like adjustment on MPOS (see below). FROM, TO,
1587 and AMOUNT are as in adjust_markers(). If MPOS doesn't need to be
1588 adjusted, nothing will happen. */
1590 do_marker_adjustment (Memind mpos, Memind from,
1591 Memind to, Bytecount amount)
1595 if (mpos > to && mpos < to + amount)
1600 if (mpos > from + amount && mpos <= from)
1601 mpos = from + amount;
1603 if (mpos > from && mpos <= to)
1608 /* Do the following:
1610 (1) Add `amount' to the position of every marker in the current buffer
1611 whose current position is between `from' (exclusive) and `to' (inclusive).
1613 (2) Also, any markers past the outside of that interval, in the direction
1614 of adjustment, are first moved back to the near end of the interval
1615 and then adjusted by `amount'.
1617 This function is called in two different cases: when a region of
1618 characters adjacent to the gap is moved, causing the gap to shift
1619 to the other side of the region (in this case, `from' and `to'
1620 point to the old position of the region and there should be no
1621 markers affected by (2) because they would be inside the gap),
1622 or when a region of characters adjacent to the gap is wiped out,
1623 causing the gap to increase to include the region (in this case,
1624 `from' and `to' are the same, both pointing to the boundary
1625 between the gap and the deleted region, and there are no markers
1628 The reason for the use of exclusive and inclusive is that markers at
1629 the gap always sit at the beginning, not at the end.
1633 adjust_markers (struct buffer *buf, Memind from, Memind to,
1636 struct Lisp_Marker *m;
1638 for (m = BUF_MARKERS (buf); m; m = marker_next (m))
1639 m->memind = do_marker_adjustment (m->memind, from, to, amount);
1642 /* Adjust markers whose insertion-type is t
1643 for an insertion of AMOUNT characters at POS. */
1646 adjust_markers_for_insert (struct buffer *buf, Memind ind, Bytecount amount)
1648 struct Lisp_Marker *m;
1650 for (m = BUF_MARKERS (buf); m; m = marker_next (m))
1652 if (m->insertion_type && m->memind == ind)
1653 m->memind += amount;
1658 /************************************************************************/
1659 /* Routines for dealing with the gap */
1660 /************************************************************************/
1662 /* XEmacs requires an ANSI C compiler, and it damn well better have a
1663 working memmove() */
1664 #define GAP_USE_BCOPY
1665 #ifdef BCOPY_UPWARD_SAFE
1666 # undef BCOPY_UPWARD_SAFE
1668 #ifdef BCOPY_DOWNWARD_SAFE
1669 # undef BCOPY_DOWNWARD_SAFE
1671 #define BCOPY_UPWARD_SAFE 1
1672 #define BCOPY_DOWNWARD_SAFE 1
1674 /* maximum amount of memory moved in a single chunk. Increasing this
1675 value improves gap-motion efficiency but decreases QUIT responsiveness
1676 time. Was 32000 but today's processors are faster and files are
1678 #define GAP_MOVE_CHUNK 300000
1680 /* Move the gap to POS, which is less than the current GPT. */
1683 gap_left (struct buffer *buf, Bytind pos)
1688 struct buffer *mbuf;
1689 Lisp_Object bufcons;
1691 from = BUF_GPT_ADDR (buf);
1692 to = from + BUF_GAP_SIZE (buf);
1693 new_s1 = BI_BUF_GPT (buf);
1695 /* Now copy the characters. To move the gap down,
1696 copy characters up. */
1700 /* I gets number of characters left to copy. */
1704 /* If a quit is requested, stop copying now.
1705 Change POS to be where we have actually moved the gap to. */
1711 /* Move at most GAP_MOVE_CHUNK chars before checking again for a quit. */
1712 if (i > GAP_MOVE_CHUNK)
1714 #ifdef GAP_USE_BCOPY
1716 /* bcopy is safe if the two areas of memory do not overlap
1717 or on systems where bcopy is always safe for moving upward. */
1718 && (BCOPY_UPWARD_SAFE
1719 || to - from >= 128))
1721 /* If overlap is not safe, avoid it by not moving too many
1722 characters at once. */
1723 if (!BCOPY_UPWARD_SAFE && i > to - from)
1727 memmove (to, from, i);
1738 /* Adjust markers, and buffer data structure, to put the gap at POS.
1739 POS is where the loop above stopped, which may be what was specified
1740 or may be where a quit was detected. */
1741 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
1743 adjust_markers (mbuf, pos, BI_BUF_GPT (mbuf), BUF_GAP_SIZE (mbuf));
1745 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
1747 adjust_extents (make_buffer (mbuf), pos, BI_BUF_GPT (mbuf),
1748 BUF_GAP_SIZE (mbuf));
1750 SET_BI_BUF_GPT (buf, pos);
1751 SET_GAP_SENTINEL (buf);
1752 #ifdef ERROR_CHECK_EXTENTS
1753 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
1755 sledgehammer_extent_check (make_buffer (mbuf));
1762 gap_right (struct buffer *buf, Bytind pos)
1767 struct buffer *mbuf;
1768 Lisp_Object bufcons;
1770 to = BUF_GPT_ADDR (buf);
1771 from = to + BUF_GAP_SIZE (buf);
1772 new_s1 = BI_BUF_GPT (buf);
1774 /* Now copy the characters. To move the gap up,
1775 copy characters down. */
1779 /* I gets number of characters left to copy. */
1783 /* If a quit is requested, stop copying now.
1784 Change POS to be where we have actually moved the gap to. */
1790 /* Move at most GAP_MOVE_CHUNK chars before checking again for a quit. */
1791 if (i > GAP_MOVE_CHUNK)
1793 #ifdef GAP_USE_BCOPY
1795 /* bcopy is safe if the two areas of memory do not overlap
1796 or on systems where bcopy is always safe for moving downward. */
1797 && (BCOPY_DOWNWARD_SAFE
1798 || from - to >= 128))
1800 /* If overlap is not safe, avoid it by not moving too many
1801 characters at once. */
1802 if (!BCOPY_DOWNWARD_SAFE && i > from - to)
1805 memmove (to, from, i);
1818 int gsize = BUF_GAP_SIZE (buf);
1819 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
1821 adjust_markers (mbuf, BI_BUF_GPT (mbuf) + gsize, pos + gsize, - gsize);
1823 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
1825 adjust_extents (make_buffer (mbuf), BI_BUF_GPT (mbuf) + gsize,
1826 pos + gsize, - gsize);
1828 SET_BI_BUF_GPT (buf, pos);
1829 SET_GAP_SENTINEL (buf);
1830 #ifdef ERROR_CHECK_EXTENTS
1831 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
1833 sledgehammer_extent_check (make_buffer (mbuf));
1837 if (pos == BI_BUF_Z (buf))
1839 /* merge gap with end gap */
1841 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + BUF_END_GAP_SIZE (buf));
1842 SET_BUF_END_GAP_SIZE (buf, 0);
1843 SET_END_SENTINEL (buf);
1849 /* Move gap to position `pos'.
1850 Note that this can quit! */
1853 move_gap (struct buffer *buf, Bytind pos)
1855 if (! BUF_BEG_ADDR (buf))
1857 if (pos < BI_BUF_GPT (buf))
1858 gap_left (buf, pos);
1859 else if (pos > BI_BUF_GPT (buf))
1860 gap_right (buf, pos);
1863 /* Merge the end gap into the gap */
1866 merge_gap_with_end_gap (struct buffer *buf)
1869 Bytind real_gap_loc;
1870 Bytecount old_gap_size;
1871 Bytecount increment;
1873 increment = BUF_END_GAP_SIZE (buf);
1874 SET_BUF_END_GAP_SIZE (buf, 0);
1878 /* Prevent quitting in move_gap. */
1879 tem = Vinhibit_quit;
1882 real_gap_loc = BI_BUF_GPT (buf);
1883 old_gap_size = BUF_GAP_SIZE (buf);
1885 /* Pretend the end gap is the gap */
1886 SET_BI_BUF_GPT (buf, BI_BUF_Z (buf) + BUF_GAP_SIZE (buf));
1887 SET_BUF_GAP_SIZE (buf, increment);
1889 /* Move the new gap down to be consecutive with the end of the old one.
1890 This adjusts the markers properly too. */
1891 gap_left (buf, real_gap_loc + old_gap_size);
1893 /* Now combine the two into one large gap. */
1894 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + old_gap_size);
1895 SET_BI_BUF_GPT (buf, real_gap_loc);
1896 SET_GAP_SENTINEL (buf);
1898 /* We changed the total size of the buffer (including gap),
1899 so we need to fix up the end sentinel. */
1900 SET_END_SENTINEL (buf);
1902 Vinhibit_quit = tem;
1906 /* Make the gap INCREMENT bytes longer. */
1909 make_gap (struct buffer *buf, Bytecount increment)
1913 Bytind real_gap_loc;
1914 Bytecount old_gap_size;
1916 /* If we have to get more space, get enough to last a while. We use
1917 a geometric progression that saves on realloc space. */
1918 increment += 2000 + ((BI_BUF_Z (buf) - BI_BUF_BEG (buf)) / 8);
1920 if (increment > BUF_END_GAP_SIZE (buf))
1922 /* Don't allow a buffer size that won't fit in an int
1923 even if it will fit in a Lisp integer.
1924 That won't work because so many places use `int'. */
1926 if (BUF_Z (buf) - BUF_BEG (buf) + BUF_GAP_SIZE (buf) + increment
1928 error ("Maximum buffer size exceeded");
1930 result = BUFFER_REALLOC (buf->text->beg,
1931 BI_BUF_Z (buf) - BI_BUF_BEG (buf) +
1932 BUF_GAP_SIZE (buf) + increment +
1933 BUF_END_SENTINEL_SIZE);
1937 SET_BUF_BEG_ADDR (buf, result);
1940 increment = BUF_END_GAP_SIZE (buf);
1942 /* Prevent quitting in move_gap. */
1943 tem = Vinhibit_quit;
1946 real_gap_loc = BI_BUF_GPT (buf);
1947 old_gap_size = BUF_GAP_SIZE (buf);
1949 /* Call the newly allocated space a gap at the end of the whole space. */
1950 SET_BI_BUF_GPT (buf, BI_BUF_Z (buf) + BUF_GAP_SIZE (buf));
1951 SET_BUF_GAP_SIZE (buf, increment);
1953 SET_BUF_END_GAP_SIZE (buf, 0);
1955 /* Move the new gap down to be consecutive with the end of the old one.
1956 This adjusts the markers properly too. */
1957 gap_left (buf, real_gap_loc + old_gap_size);
1959 /* Now combine the two into one large gap. */
1960 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + old_gap_size);
1961 SET_BI_BUF_GPT (buf, real_gap_loc);
1962 SET_GAP_SENTINEL (buf);
1964 /* We changed the total size of the buffer (including gap),
1965 so we need to fix up the end sentinel. */
1966 SET_END_SENTINEL (buf);
1968 Vinhibit_quit = tem;
1972 /************************************************************************/
1973 /* Before/after-change processing */
1974 /************************************************************************/
1976 /* Those magic changes ... */
1979 buffer_signal_changed_region (struct buffer *buf, Bufpos start,
1982 /* The changed region is recorded as the number of unchanged
1983 characters from the beginning and from the end of the
1984 buffer. This obviates much of the need of shifting the
1985 region around to compensate for insertions and deletions.
1987 if (buf->changes->begin_unchanged < 0 ||
1988 buf->changes->begin_unchanged > start - BUF_BEG (buf))
1989 buf->changes->begin_unchanged = start - BUF_BEG (buf);
1990 if (buf->changes->end_unchanged < 0 ||
1991 buf->changes->end_unchanged > BUF_Z (buf) - end)
1992 buf->changes->end_unchanged = BUF_Z (buf) - end;
1996 buffer_extent_signal_changed_region (struct buffer *buf, Bufpos start,
1999 if (buf->changes->begin_extent_unchanged < 0 ||
2000 buf->changes->begin_extent_unchanged > start - BUF_BEG (buf))
2001 buf->changes->begin_extent_unchanged = start - BUF_BEG (buf);
2002 if (buf->changes->end_extent_unchanged < 0 ||
2003 buf->changes->end_extent_unchanged > BUF_Z (buf) - end)
2004 buf->changes->end_extent_unchanged = BUF_Z (buf) - end;
2008 buffer_reset_changes (struct buffer *buf)
2010 buf->changes->begin_unchanged = -1;
2011 buf->changes->end_unchanged = -1;
2012 buf->changes->begin_extent_unchanged = -1;
2013 buf->changes->end_extent_unchanged = -1;
2014 buf->changes->newline_was_deleted = 0;
2018 signal_after_change (struct buffer *buf, Bufpos start, Bufpos orig_end,
2022 /* Call the after-change-functions according to the changes made so far
2023 and treat all further changes as single until the outermost
2024 multiple change exits. This is called when the outermost multiple
2025 change exits and when someone is trying to make a change that violates
2026 the constraints specified in begin_multiple_change(), typically
2027 when nested multiple-change sessions occur. (There are smarter ways of
2028 dealing with nested multiple changes, but these rarely occur so there's
2029 probably no point in it.) */
2031 /* #### This needs to keep track of what actually changed and only
2032 call the after-change functions on that region. */
2035 cancel_multiple_change (struct buffer *buf)
2037 /* This function can GC */
2038 /* Call the after-change-functions except when they've already been
2039 called or when there were no changes made to the buffer at all. */
2040 if (buf->text->changes->mc_begin != 0 &&
2041 buf->text->changes->mc_begin_signaled)
2043 Bufpos real_mc_begin = buf->text->changes->mc_begin;
2044 buf->text->changes->mc_begin = 0;
2046 signal_after_change (buf, real_mc_begin, buf->text->changes->mc_orig_end,
2047 buf->text->changes->mc_new_end);
2051 buf->text->changes->mc_begin = 0;
2055 /* this is an unwind_protect, to ensure that the after-change-functions
2056 get called even in a non-local exit. */
2059 multiple_change_finish_up (Lisp_Object buffer)
2061 struct buffer *buf = XBUFFER (buffer);
2063 /* #### I don't know whether or not it should even be possible to
2064 get here with a dead buffer (though given how it is called I can
2065 see how it might be). In any case, there isn't time before 19.14
2067 if (!BUFFER_LIVE_P (buf))
2070 /* This function can GC */
2071 buf->text->changes->in_multiple_change = 0; /* do this first so that
2072 errors in the after-change
2073 functions don't mess things
2075 cancel_multiple_change (buf);
2079 /* Call this function when you're about to make a number of buffer changes
2080 that should be considered a single change. (e.g. `replace-match' calls
2081 this.) You need to specify the START and END of the region that is
2082 going to be changed so that the before-change-functions are called
2083 with the correct arguments. The after-change region is calculated
2084 automatically, however, and if changes somehow or other happen outside
2085 of the specified region, that will also be handled correctly.
2087 begin_multiple_change() returns a number (actually a specpdl depth)
2088 that you must pass to end_multiple_change() when you are done.
2090 FSF Emacs 20 implements a similar feature, accessible from Lisp
2091 through a `combine-after-change-calls' special form, which is
2092 essentially equivalent to this function. We should consider
2093 whether we want to introduce a similar Lisp form. */
2096 begin_multiple_change (struct buffer *buf, Bufpos start, Bufpos end)
2098 /* This function can GC */
2100 if (buf->text->changes->in_multiple_change)
2102 if (buf->text->changes->mc_begin != 0 &&
2103 (start < buf->text->changes->mc_begin ||
2104 end > buf->text->changes->mc_new_end))
2105 cancel_multiple_change (buf);
2111 buf->text->changes->mc_begin = start;
2112 buf->text->changes->mc_orig_end = buf->text->changes->mc_new_end = end;
2113 buf->text->changes->mc_begin_signaled = 0;
2114 count = specpdl_depth ();
2115 XSETBUFFER (buffer, buf);
2116 record_unwind_protect (multiple_change_finish_up, buffer);
2118 buf->text->changes->in_multiple_change++;
2119 /* We don't call before-change-functions until signal_before_change()
2120 is called, in case there is a read-only or other error. */
2125 end_multiple_change (struct buffer *buf, int count)
2127 assert (buf->text->changes->in_multiple_change > 0);
2128 buf->text->changes->in_multiple_change--;
2129 if (!buf->text->changes->in_multiple_change)
2130 unbind_to (count, Qnil);
2133 static int inside_change_hook;
2136 change_function_restore (Lisp_Object buffer)
2138 /* We should first reset the variable and then change the buffer,
2139 because Fset_buffer() can throw. */
2140 inside_change_hook = 0;
2141 if (XBUFFER (buffer) != current_buffer)
2142 Fset_buffer (buffer);
2146 static int in_first_change;
2149 first_change_hook_restore (Lisp_Object buffer)
2151 in_first_change = 0;
2152 Fset_buffer (buffer);
2156 /* Signal an initial modification to the buffer. */
2159 signal_first_change (struct buffer *buf)
2161 /* This function can GC */
2163 XSETBUFFER (buffer, current_buffer);
2165 if (!in_first_change)
2167 if (!NILP (symbol_value_in_buffer (Qfirst_change_hook, buffer)))
2169 int speccount = specpdl_depth ();
2170 record_unwind_protect (first_change_hook_restore, buffer);
2171 set_buffer_internal (buf);
2172 in_first_change = 1;
2173 run_hook (Qfirst_change_hook);
2174 unbind_to (speccount, Qnil);
2179 /* Signal a change to the buffer immediately before it happens.
2180 START and END are the bounds of the text to be changed. */
2183 signal_before_change (struct buffer *buf, Bufpos start, Bufpos end)
2185 /* This function can GC */
2186 struct buffer *mbuf;
2187 Lisp_Object bufcons;
2189 if (!inside_change_hook)
2194 /* Are we in a multiple-change session? */
2195 if (buf->text->changes->in_multiple_change &&
2196 buf->text->changes->mc_begin != 0)
2198 /* If we're violating the constraints of the session,
2199 call the after-change-functions as necessary for the
2200 changes already made and treat further changes as
2202 if (start < buf->text->changes->mc_begin ||
2203 end > buf->text->changes->mc_new_end)
2204 cancel_multiple_change (buf);
2205 /* Do nothing if this is not the first change in the session. */
2206 else if (buf->text->changes->mc_begin_signaled)
2210 /* First time through; call the before-change-functions
2211 specifying the entire region to be changed. (Note that
2212 we didn't call before-change-functions in
2213 begin_multiple_change() because the buffer might be
2215 start = buf->text->changes->mc_begin;
2216 end = buf->text->changes->mc_new_end;
2220 /* If buffer is unmodified, run a special hook for that case. */
2221 if (BUF_SAVE_MODIFF (buf) >= BUF_MODIFF (buf))
2223 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2225 signal_first_change (mbuf);
2229 /* Now in any case run the before-change-functions if any. */
2230 speccount = specpdl_depth ();
2231 record_unwind_protect (change_function_restore, Fcurrent_buffer ());
2232 inside_change_hook = 1;
2234 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2236 XSETBUFFER (buffer, mbuf);
2237 if (!NILP (symbol_value_in_buffer (Qbefore_change_functions, buffer))
2238 /* Obsolete, for compatibility */
2239 || !NILP (symbol_value_in_buffer (Qbefore_change_function, buffer)))
2241 set_buffer_internal (buf);
2242 va_run_hook_with_args (Qbefore_change_functions, 2,
2243 make_int (start), make_int (end));
2244 /* Obsolete, for compatibility */
2245 va_run_hook_with_args (Qbefore_change_function, 2,
2246 make_int (start), make_int (end));
2250 /* Make sure endpoints remain valid. before-change-functions
2251 might have modified the buffer. */
2252 if (start < BUF_BEGV (buf)) start = BUF_BEGV (buf);
2253 if (start > BUF_ZV (buf)) start = BUF_ZV (buf);
2254 if (end < BUF_BEGV (buf)) end = BUF_BEGV (buf);
2255 if (end > BUF_ZV (buf)) end = BUF_ZV (buf);
2257 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2259 XSETBUFFER (buffer, mbuf);
2260 report_extent_modification (buffer, start, end, 0);
2262 unbind_to (speccount, Qnil);
2264 /* Only now do we indicate that the before-change-functions have
2265 been called, in case some function throws out. */
2266 buf->text->changes->mc_begin_signaled = 1;
2270 /* Signal a change immediately after it happens.
2271 START is the bufpos of the start of the changed text.
2272 ORIG_END is the bufpos of the end of the before-changed text.
2273 NEW_END is the bufpos of the end of the after-changed text.
2277 signal_after_change (struct buffer *buf, Bufpos start, Bufpos orig_end,
2280 /* This function can GC */
2281 struct buffer *mbuf;
2282 Lisp_Object bufcons;
2284 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2286 /* always do this. */
2287 buffer_signal_changed_region (mbuf, start, new_end);
2289 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2291 /* #### This seems inefficient. Wouldn't it be better to just
2292 keep one cache per base buffer? */
2293 font_lock_maybe_update_syntactic_caches (mbuf, start, orig_end, new_end);
2296 if (!inside_change_hook)
2301 if (buf->text->changes->in_multiple_change &&
2302 buf->text->changes->mc_begin != 0)
2304 assert (start >= buf->text->changes->mc_begin &&
2305 start <= buf->text->changes->mc_new_end);
2306 assert (orig_end >= buf->text->changes->mc_begin &&
2307 orig_end <= buf->text->changes->mc_new_end);
2308 buf->text->changes->mc_new_end += new_end - orig_end;
2309 return; /* after-change-functions signalled when all changes done */
2312 speccount = specpdl_depth ();
2313 record_unwind_protect (change_function_restore, Fcurrent_buffer ());
2314 inside_change_hook = 1;
2315 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2317 XSETBUFFER (buffer, mbuf);
2319 if (!NILP (symbol_value_in_buffer (Qafter_change_functions, buffer))
2320 /* Obsolete, for compatibility */
2321 || !NILP (symbol_value_in_buffer (Qafter_change_function, buffer)))
2323 set_buffer_internal (buf);
2324 /* The actual after-change functions take slightly
2325 different arguments than what we were passed. */
2326 va_run_hook_with_args (Qafter_change_functions, 3,
2327 make_int (start), make_int (new_end),
2328 make_int (orig_end - start));
2329 /* Obsolete, for compatibility */
2330 va_run_hook_with_args (Qafter_change_function, 3,
2331 make_int (start), make_int (new_end),
2332 make_int (orig_end - start));
2336 /* Make sure endpoints remain valid. after-change-functions
2337 might have modified the buffer. */
2338 if (start < BUF_BEGV (buf)) start = BUF_BEGV (buf);
2339 if (start > BUF_ZV (buf)) start = BUF_ZV (buf);
2340 if (new_end < BUF_BEGV (buf)) new_end = BUF_BEGV (buf);
2341 if (new_end > BUF_ZV (buf)) new_end = BUF_ZV (buf);
2342 if (orig_end < BUF_BEGV (buf)) orig_end = BUF_BEGV (buf);
2343 if (orig_end > BUF_ZV (buf)) orig_end = BUF_ZV (buf);
2345 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2347 XSETBUFFER (buffer, mbuf);
2348 report_extent_modification (buffer, start, new_end, 1);
2350 unbind_to (speccount, Qnil); /* sets inside_change_hook back to 0 */
2354 /* Call this if you're about to change the region of BUFFER from START
2355 to END. This checks the read-only properties of the region, calls
2356 the necessary modification hooks, and warns the next redisplay that
2357 it should pay attention to that area. */
2360 prepare_to_modify_buffer (struct buffer *buf, Bufpos start, Bufpos end,
2363 /* This function can GC */
2364 /* dmoore - This function can also kill the buffer buf, the current
2365 buffer, and do anything it pleases. So if you call it, be
2367 struct buffer *mbuf;
2368 Lisp_Object buffer, bufcons;
2369 struct gcpro gcpro1;
2371 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2373 barf_if_buffer_read_only (mbuf, start, end);
2376 /* if this is the first modification, see about locking the buffer's
2378 XSETBUFFER (buffer, buf);
2380 if (!NILP (buf->filename) && lockit &&
2381 BUF_SAVE_MODIFF (buf) >= BUF_MODIFF (buf))
2383 #ifdef CLASH_DETECTION
2384 if (!NILP (buf->file_truename))
2385 /* Make binding buffer-file-name to nil effective. */
2386 lock_file (buf->file_truename);
2388 /* At least warn if this file has changed on disk since it was visited.*/
2389 if (NILP (Fverify_visited_file_modtime (buffer))
2390 && !NILP (Ffile_exists_p (buf->filename)))
2391 call1_in_buffer (buf, intern ("ask-user-about-supersession-threat"),
2393 #endif /* not CLASH_DETECTION */
2397 /* #### dmoore - is this reasonable in case of buf being killed above? */
2398 if (!BUFFER_LIVE_P (buf))
2401 signal_before_change (buf, start, end);
2403 #ifdef REGION_CACHE_NEEDS_WORK
2404 if (buf->newline_cache)
2405 invalidate_region_cache (buf,
2407 start - BUF_BEG (buf), BUF_Z (buf) - end);
2408 if (buf->width_run_cache)
2409 invalidate_region_cache (buf,
2410 buf->width_run_cache,
2411 start - BUF_BEG (buf), BUF_Z (buf) - end);
2415 Vdeactivate_mark = Qt;
2418 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2420 mbuf->point_before_scroll = Qnil;
2425 /************************************************************************/
2426 /* Insertion of strings */
2427 /************************************************************************/
2430 fixup_internal_substring (CONST Bufbyte *nonreloc, Lisp_Object reloc,
2431 Bytecount offset, Bytecount *len)
2433 assert ((nonreloc && NILP (reloc)) || (!nonreloc && STRINGP (reloc)));
2438 *len = strlen ((CONST char *) nonreloc) - offset;
2440 *len = XSTRING_LENGTH (reloc) - offset;
2442 #ifdef ERROR_CHECK_BUFPOS
2444 if (STRINGP (reloc))
2446 assert (offset >= 0 && offset <= XSTRING_LENGTH (reloc));
2447 assert (offset + *len <= XSTRING_LENGTH (reloc));
2452 /* Insert a string into BUF at Bufpos POS. The string data comes
2453 from one of two sources: constant, non-relocatable data (specified
2454 in NONRELOC), or a Lisp string object (specified in RELOC), which
2455 is relocatable and may have extent data that needs to be copied
2456 into the buffer. OFFSET and LENGTH specify the substring of the
2457 data that is actually to be inserted. As a special case, if POS
2458 is -1, insert the string at point and move point to the end of the
2461 Normally, markers at the insertion point end up before the
2462 inserted string. If INSDEL_BEFORE_MARKERS is set in flags, however,
2463 they end up after the string.
2465 INSDEL_NO_LOCKING is kludgy and is used when insert-file-contents is
2466 visiting a new file; it inhibits the locking checks normally done
2467 before modifying a buffer. Similar checks were already done
2468 in the higher-level Lisp functions calling insert-file-contents. */
2471 buffer_insert_string_1 (struct buffer *buf, Bufpos pos,
2472 CONST Bufbyte *nonreloc, Lisp_Object reloc,
2473 Bytecount offset, Bytecount length,
2476 /* This function can GC */
2477 struct gcpro gcpro1;
2481 struct buffer *mbuf;
2482 Lisp_Object bufcons;
2484 /* Defensive steps just in case a buffer gets deleted and a calling
2485 function doesn't notice it. */
2486 if (!BUFFER_LIVE_P (buf))
2489 fixup_internal_substring (nonreloc, reloc, offset, &length);
2498 /* #### See the comment in print_internal(). If this buffer is marked
2499 as translatable, then Fgettext() should be called on obj if it
2503 /* Make sure that point-max won't exceed the size of an emacs int. */
2504 if ((length + BUF_Z (buf)) > EMACS_INT_MAX)
2505 error ("Maximum buffer size exceeded");
2507 /* theoretically not necessary -- caller should GCPRO.
2508 #### buffer_insert_from_buffer_1() doesn't! */
2511 prepare_to_modify_buffer (buf, pos, pos, !(flags & INSDEL_NO_LOCKING));
2513 /* Defensive steps in case the before-change-functions fuck around */
2514 if (!BUFFER_LIVE_P (buf))
2517 /* Bad bad pre-change function. */
2521 /* Make args be valid again. prepare_to_modify_buffer() might have
2522 modified the buffer. */
2523 if (pos < BUF_BEGV (buf))
2524 pos = BUF_BEGV (buf);
2525 if (pos > BUF_ZV (buf))
2528 /* string may have been relocated up to this point */
2529 if (STRINGP (reloc))
2530 nonreloc = XSTRING_DATA (reloc);
2532 ind = bufpos_to_bytind (buf, pos);
2533 cclen = bytecount_to_charcount (nonreloc + offset, length);
2535 if (ind != BI_BUF_GPT (buf))
2536 /* #### if debug-on-quit is invoked and the user changes the
2537 buffer, bad things can happen. This is a rampant problem
2539 move_gap (buf, ind); /* may QUIT */
2540 if (! GAP_CAN_HOLD_SIZE_P (buf, length))
2542 if (BUF_END_GAP_SIZE (buf) >= length)
2543 merge_gap_with_end_gap (buf);
2545 make_gap (buf, length - BUF_GAP_SIZE (buf));
2548 insert_invalidate_line_number_cache (buf, pos, nonreloc + offset, length);
2550 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2552 record_insert (mbuf, pos, cclen);
2556 MARK_BUFFERS_CHANGED;
2558 /* string may have been relocated up to this point */
2559 if (STRINGP (reloc))
2560 nonreloc = XSTRING_DATA (reloc);
2562 memcpy (BUF_GPT_ADDR (buf), nonreloc + offset, length);
2564 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) - length);
2565 SET_BI_BUF_GPT (buf, BI_BUF_GPT (buf) + length);
2566 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2568 SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) + cclen, BI_BUF_ZV (mbuf) + length);
2570 SET_BOTH_BUF_Z (buf, BUF_Z (buf) + cclen, BI_BUF_Z (buf) + length);
2571 SET_GAP_SENTINEL (buf);
2574 buffer_mule_signal_inserted_region (buf, pos, length, cclen);
2577 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2579 process_extents_for_insertion (make_buffer (mbuf), ind, length);
2582 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2584 /* We know the gap is at IND so the cast is OK. */
2585 adjust_markers_for_insert (mbuf, (Memind) ind, length);
2588 /* Point logically doesn't move, but may need to be adjusted because
2589 it's a byte index. point-marker doesn't change because it's a
2591 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2593 if (BI_BUF_PT (mbuf) > ind)
2594 JUST_SET_POINT (mbuf, BUF_PT (mbuf) + cclen,
2595 BI_BUF_PT (mbuf) + length);
2598 /* Well, point might move. */
2600 BI_BUF_SET_PT (buf, ind + length);
2602 if (STRINGP (reloc))
2604 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2606 splice_in_string_extents (reloc, mbuf, ind, length, offset);
2610 if (flags & INSDEL_BEFORE_MARKERS)
2612 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2614 /* ind - 1 is correct because the FROM argument is exclusive.
2615 I formerly used DEC_BYTIND() but that caused problems at the
2616 beginning of the buffer. */
2617 adjust_markers (mbuf, ind - 1, ind, length);
2621 signal_after_change (buf, pos, pos, pos + cclen);
2629 /* The following functions are interfaces onto the above function,
2630 for inserting particular sorts of data. In all the functions,
2631 BUF and POS specify the buffer and location where the insertion is
2632 to take place. (If POS is -1, text is inserted at point and point
2633 moves forward past the text.) FLAGS is as above. */
2636 buffer_insert_raw_string_1 (struct buffer *buf, Bufpos pos,
2637 CONST Bufbyte *nonreloc, Bytecount length,
2640 /* This function can GC */
2641 return buffer_insert_string_1 (buf, pos, nonreloc, Qnil, 0, length,
2646 buffer_insert_lisp_string_1 (struct buffer *buf, Bufpos pos, Lisp_Object str,
2649 /* This function can GC */
2650 #ifdef ERROR_CHECK_TYPECHECK
2651 assert (STRINGP (str));
2653 return buffer_insert_string_1 (buf, pos, 0, str, 0,
2654 XSTRING_LENGTH (str),
2658 /* Insert the null-terminated string S (in external format). */
2661 buffer_insert_c_string_1 (struct buffer *buf, Bufpos pos, CONST char *s,
2664 /* This function can GC */
2665 CONST char *translated = GETTEXT (s);
2666 return buffer_insert_string_1 (buf, pos, (CONST Bufbyte *) translated, Qnil,
2667 0, strlen (translated), flags);
2671 buffer_insert_emacs_char_1 (struct buffer *buf, Bufpos pos, Emchar ch,
2674 /* This function can GC */
2675 Bufbyte str[MAX_EMCHAR_LEN];
2676 Bytecount len = set_charptr_emchar (str, ch);
2677 return buffer_insert_string_1 (buf, pos, str, Qnil, 0, len, flags);
2681 buffer_insert_c_char_1 (struct buffer *buf, Bufpos pos, char c,
2684 /* This function can GC */
2685 return buffer_insert_emacs_char_1 (buf, pos, (Emchar) (unsigned char) c,
2690 buffer_insert_from_buffer_1 (struct buffer *buf, Bufpos pos,
2691 struct buffer *buf2, Bufpos pos2,
2692 Charcount length, int flags)
2694 /* This function can GC */
2695 Lisp_Object str = make_string_from_buffer (buf2, pos2, length);
2696 return buffer_insert_string_1 (buf, pos, 0, str, 0,
2697 XSTRING_LENGTH (str), flags);
2701 /************************************************************************/
2702 /* Deletion of ranges */
2703 /************************************************************************/
2705 /* Delete characters in buffer from FROM up to (but not including) TO. */
2708 buffer_delete_range (struct buffer *buf, Bufpos from, Bufpos to, int flags)
2710 /* This function can GC */
2712 Bytind bi_from, bi_to;
2713 Bytecount bc_numdel;
2715 struct buffer *mbuf;
2716 Lisp_Object bufcons;
2718 /* Defensive steps just in case a buffer gets deleted and a calling
2719 function doesn't notice it. */
2720 if (!BUFFER_LIVE_P (buf))
2723 /* Make args be valid */
2724 if (from < BUF_BEGV (buf))
2725 from = BUF_BEGV (buf);
2726 if (to > BUF_ZV (buf))
2728 if ((numdel = to - from) <= 0)
2731 prepare_to_modify_buffer (buf, from, to, !(flags & INSDEL_NO_LOCKING));
2733 /* Defensive steps in case the before-change-functions fuck around */
2734 if (!BUFFER_LIVE_P (buf))
2735 /* Bad bad pre-change function. */
2738 /* Make args be valid again. prepare_to_modify_buffer() might have
2739 modified the buffer. */
2740 if (from < BUF_BEGV (buf))
2741 from = BUF_BEGV (buf);
2742 if (to > BUF_ZV (buf))
2744 if ((numdel = to - from) <= 0)
2747 /* Redisplay needs to know if a newline was in the deleted region.
2748 If we've already marked the changed region as having a deleted
2749 newline there is no use in performing the check. */
2750 if (!buf->changes->newline_was_deleted)
2752 scan_buffer (buf, '\n', from, to, 1, &shortage, 1);
2755 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2757 mbuf->changes->newline_was_deleted = 1;
2762 bi_from = bufpos_to_bytind (buf, from);
2763 bi_to = bufpos_to_bytind (buf, to);
2764 bc_numdel = bi_to - bi_from;
2766 delete_invalidate_line_number_cache (buf, from, to);
2768 if (to == BUF_Z (buf) &&
2769 bi_from > BI_BUF_GPT (buf))
2771 /* avoid moving the gap just to delete from the bottom. */
2773 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2775 record_delete (mbuf, from, numdel);
2778 MARK_BUFFERS_CHANGED;
2780 /* #### Point used to be modified here, but this causes problems
2781 with MULE, as point is used to calculate bytinds, and if the
2782 offset in bc_numdel causes point to move to a non first-byte
2783 location, causing some other function to throw an assertion
2784 in ASSERT_VALID_BYTIND. I've moved the code to right after
2785 the other movements and adjustments, but before the gap is
2786 moved. -- jh 970813 */
2788 /* Detach any extents that are completely within the range [FROM, TO],
2789 if the extents are detachable.
2791 This must come AFTER record_delete(), so that the appropriate
2792 extents will be present to be recorded, and BEFORE the gap
2793 size is increased, as otherwise we will be confused about
2794 where the extents end. */
2795 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2797 process_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to, 0);
2800 /* Relocate all markers pointing into the new, larger gap to
2801 point at the end of the text before the gap. */
2802 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2804 adjust_markers (mbuf,
2805 (bi_to + BUF_GAP_SIZE (mbuf)),
2806 (bi_to + BUF_GAP_SIZE (mbuf)),
2810 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2812 /* Relocate any extent endpoints just like markers. */
2813 adjust_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to,
2814 BUF_GAP_SIZE (mbuf), bc_numdel, 0);
2817 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2819 /* Relocate point as if it were a marker. */
2820 if (bi_from < BI_BUF_PT (mbuf))
2822 if (BI_BUF_PT (mbuf) < bi_to)
2823 JUST_SET_POINT (mbuf, from, bi_from);
2825 JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
2826 BI_BUF_PT (mbuf) - bc_numdel);
2830 SET_BUF_END_GAP_SIZE (buf, BUF_END_GAP_SIZE (buf) + bc_numdel);
2832 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2834 SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
2835 BI_BUF_ZV (mbuf) - bc_numdel);
2837 SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
2838 SET_GAP_SENTINEL (buf);
2842 /* Make sure the gap is somewhere in or next to what we are deleting. */
2843 if (bi_to < BI_BUF_GPT (buf))
2844 gap_left (buf, bi_to);
2845 if (bi_from > BI_BUF_GPT (buf))
2846 gap_right (buf, bi_from);
2848 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2850 record_delete (mbuf, from, numdel);
2853 MARK_BUFFERS_CHANGED;
2855 /* #### Point used to be modified here, but this causes problems
2856 with MULE, as point is used to calculate bytinds, and if the
2857 offset in bc_numdel causes point to move to a non first-byte
2858 location, causing some other function to throw an assertion
2859 in ASSERT_VALID_BYTIND. I've moved the code to right after
2860 the other movements and adjustments, but before the gap is
2861 moved. -- jh 970813 */
2863 /* Detach any extents that are completely within the range [FROM, TO],
2864 if the extents are detachable.
2866 This must come AFTER record_delete(), so that the appropriate extents
2867 will be present to be recorded, and BEFORE the gap size is increased,
2868 as otherwise we will be confused about where the extents end. */
2869 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2871 process_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to, 0);
2874 /* Relocate all markers pointing into the new, larger gap to
2875 point at the end of the text before the gap. */
2876 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2878 adjust_markers (mbuf,
2879 (bi_to + BUF_GAP_SIZE (mbuf)),
2880 (bi_to + BUF_GAP_SIZE (mbuf)),
2881 (- bc_numdel - BUF_GAP_SIZE (mbuf)));
2884 /* Relocate any extent endpoints just like markers. */
2885 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2887 adjust_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to,
2888 BUF_GAP_SIZE (mbuf),
2889 bc_numdel, BUF_GAP_SIZE (mbuf));
2892 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2894 /* Relocate point as if it were a marker. */
2895 if (bi_from < BI_BUF_PT (mbuf))
2897 if (BI_BUF_PT (mbuf) < bi_to)
2898 JUST_SET_POINT (mbuf, from, bi_from);
2900 JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
2901 BI_BUF_PT (mbuf) - bc_numdel);
2905 SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + bc_numdel);
2906 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2908 SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
2909 BI_BUF_ZV (mbuf) - bc_numdel);
2911 SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
2912 SET_BI_BUF_GPT (buf, bi_from);
2913 SET_GAP_SENTINEL (buf);
2917 buffer_mule_signal_deleted_region (buf, from, to, bi_from, bi_to);
2920 #ifdef ERROR_CHECK_EXTENTS
2921 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2923 sledgehammer_extent_check (make_buffer (mbuf));
2927 signal_after_change (buf, from, to, from);
2931 /************************************************************************/
2932 /* Replacement of characters */
2933 /************************************************************************/
2935 /* Replace the character at POS in buffer B with CH. */
2938 buffer_replace_char (struct buffer *buf, Bufpos pos, Emchar ch,
2939 int not_real_change, int force_lock_check)
2941 /* This function can GC */
2942 Bufbyte curstr[MAX_EMCHAR_LEN];
2943 Bufbyte newstr[MAX_EMCHAR_LEN];
2944 Bytecount curlen, newlen;
2946 /* Defensive steps just in case a buffer gets deleted and a calling
2947 function doesn't notice it. */
2948 if (!BUFFER_LIVE_P (buf))
2951 curlen = BUF_CHARPTR_COPY_CHAR (buf, pos, curstr);
2952 newlen = set_charptr_emchar (newstr, ch);
2954 if (curlen == newlen)
2956 struct buffer *mbuf;
2957 Lisp_Object bufcons;
2959 /* then we can just replace the text. */
2960 prepare_to_modify_buffer (buf, pos, pos + 1,
2961 !not_real_change || force_lock_check);
2962 /* Defensive steps in case the before-change-functions fuck around */
2963 if (!BUFFER_LIVE_P (buf))
2964 /* Bad bad pre-change function. */
2967 /* Make args be valid again. prepare_to_modify_buffer() might have
2968 modified the buffer. */
2969 if (pos < BUF_BEGV (buf))
2970 pos = BUF_BEGV (buf);
2971 if (pos >= BUF_ZV (buf))
2972 pos = BUF_ZV (buf) - 1;
2973 if (pos < BUF_BEGV (buf))
2974 /* no more characters in buffer! */
2977 if (BUF_FETCH_CHAR (buf, pos) == '\n')
2979 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2981 mbuf->changes->newline_was_deleted = 1;
2984 MARK_BUFFERS_CHANGED;
2985 if (!not_real_change)
2987 MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
2989 record_change (mbuf, pos, 1);
2993 memcpy (BUF_BYTE_ADDRESS (buf, pos), newstr, newlen);
2995 signal_after_change (buf, pos, pos + 1, pos + 1);
2997 /* We do not have to adjust the Mule data; we just replaced a
2998 character with another of the same number of bytes. */
3003 * Must implement as deletion followed by insertion.
3005 * Make a note to move point forward later in the one situation
3006 * where it is needed, a delete/insert one position behind
3007 * point. Point will drift backward by one position and stay
3010 int movepoint = (pos == BUF_PT (buf) - 1);
3012 buffer_delete_range (buf, pos, pos + 1, 0);
3013 /* Defensive steps in case the before-change-functions fuck around */
3014 if (!BUFFER_LIVE_P (buf))
3015 /* Bad bad pre-change function. */
3018 /* Make args be valid again. prepare_to_modify_buffer() might have
3019 modified the buffer. */
3020 if (pos < BUF_BEGV (buf))
3021 pos = BUF_BEGV (buf);
3022 if (pos >= BUF_ZV (buf))
3023 pos = BUF_ZV (buf) - 1;
3024 if (pos < BUF_BEGV (buf))
3025 /* no more characters in buffer! */
3028 * -1 as the pos argument means to move point forward with the
3029 * insertion, which we must do if the deletion moved point
3030 * backward so that it now equals the insertion point.
3032 buffer_insert_string_1 (buf, (movepoint ? -1 : pos),
3033 newstr, Qnil, 0, newlen, 0);
3038 /************************************************************************/
3039 /* Other functions */
3040 /************************************************************************/
3042 /* Make a string from a buffer. This needs to take into account the gap,
3043 and add any necessary extents from the buffer. */
3046 make_string_from_buffer_1 (struct buffer *buf, Bufpos pos, Charcount length,
3049 /* This function can GC */
3050 Bytind bi_ind = bufpos_to_bytind (buf, pos);
3051 Bytecount bi_len = bufpos_to_bytind (buf, pos + length) - bi_ind;
3052 Lisp_Object val = make_uninit_string (bi_len);
3054 struct gcpro gcpro1;
3058 add_string_extents (val, buf, bi_ind, bi_len);
3061 Bytecount len1 = BI_BUF_GPT (buf) - bi_ind;
3062 Bufbyte *start1 = BI_BUF_BYTE_ADDRESS (buf, bi_ind);
3063 Bufbyte *dest = XSTRING_DATA (val);
3067 /* Completely after gap */
3068 memcpy (dest, start1, bi_len);
3070 else if (bi_len <= len1)
3072 /* Completely before gap */
3073 memcpy (dest, start1, bi_len);
3078 Bytind pos2 = bi_ind + len1;
3079 Bufbyte *start2 = BI_BUF_BYTE_ADDRESS (buf, pos2);
3081 memcpy (dest, start1, len1);
3082 memcpy (dest + len1, start2, bi_len - len1);
3091 make_string_from_buffer (struct buffer *buf, Bufpos pos, Charcount length)
3093 return make_string_from_buffer_1 (buf, pos, length, 0);
3097 make_string_from_buffer_no_extents (struct buffer *buf, Bufpos pos,
3100 return make_string_from_buffer_1 (buf, pos, length, 1);
3104 barf_if_buffer_read_only (struct buffer *buf, Bufpos from, Bufpos to)
3109 XSETBUFFER (buffer, buf);
3111 iro = (buf == current_buffer ? Vinhibit_read_only :
3112 symbol_value_in_buffer (Qinhibit_read_only, buffer));
3115 if (NILP (iro) && !NILP (buf->read_only))
3117 Fsignal (Qbuffer_read_only, (list1 (buffer)));
3124 verify_extent_modification (buffer,
3125 bufpos_to_bytind (buf, from),
3126 bufpos_to_bytind (buf, to),
3132 find_charsets_in_bufbyte_string (Charset_ID *charsets, CONST Bufbyte *str,
3136 /* Telescope this. */
3139 CONST Bufbyte *strend = str + len;
3140 memset (charsets, 0, NUM_LEADING_BYTES * sizeof(Charset_ID));
3142 while (str < strend)
3145 charsets[CHAR_CHARSET_ID (charptr_emchar (str))
3146 - MIN_LEADING_BYTE] = 1;
3147 #else /* I'm not sure the definition for UTF2000 works with leading-byte
3149 charsets[CHAR_LEADING_BYTE (charptr_emchar (str))
3150 - MIN_LEADING_BYTE] = 1;
3158 find_charsets_in_emchar_string (Charset_ID *charsets, CONST Emchar *str,
3162 /* Telescope this. */
3167 memset (charsets, 0, NUM_LEADING_BYTES * sizeof(Charset_ID));
3168 for (i = 0; i < len; i++)
3171 charsets[CHAR_CHARSET_ID (str[i]) - MIN_LEADING_BYTE] = 1;
3172 #else /* I'm not sure the definition for UTF2000 works with leading-byte
3174 charsets[CHAR_LEADING_BYTE (str[i]) - MIN_LEADING_BYTE] = 1;
3181 bufbyte_string_displayed_columns (CONST Bufbyte *str, Bytecount len)
3184 CONST Bufbyte *end = str + len;
3189 Emchar ch = charptr_emchar (str);
3190 cols += CHAR_COLUMNS (ch);
3201 emchar_string_displayed_columns (CONST Emchar *str, Charcount len)
3207 for (i = 0; i < len; i++)
3208 cols += CHAR_COLUMNS (str[i]);
3211 #else /* not MULE */
3216 /* NOTE: Does not reset the Dynarr. */
3219 convert_bufbyte_string_into_emchar_dynarr (CONST Bufbyte *str, Bytecount len,
3222 CONST Bufbyte *strend = str + len;
3224 while (str < strend)
3226 Emchar ch = charptr_emchar (str);
3227 Dynarr_add (dyn, ch);
3233 convert_bufbyte_string_into_emchar_string (CONST Bufbyte *str, Bytecount len,
3236 CONST Bufbyte *strend = str + len;
3237 Charcount newlen = 0;
3238 while (str < strend)
3240 Emchar ch = charptr_emchar (str);
3247 /* Convert an array of Emchars into the equivalent string representation.
3248 Store into the given Bufbyte dynarr. Does not reset the dynarr.
3249 Does not add a terminating zero. */
3252 convert_emchar_string_into_bufbyte_dynarr (Emchar *arr, int nels,
3253 Bufbyte_dynarr *dyn)
3255 Bufbyte str[MAX_EMCHAR_LEN];
3258 for (i = 0; i < nels; i++)
3260 Bytecount len = set_charptr_emchar (str, arr[i]);
3261 Dynarr_add_many (dyn, str, len);
3265 /* Convert an array of Emchars into the equivalent string representation.
3266 Malloc the space needed for this and return it. If LEN_OUT is not a
3267 NULL pointer, store into LEN_OUT the number of Bufbytes in the
3268 malloc()ed string. Note that the actual number of Bufbytes allocated
3269 is one more than this: the returned string is zero-terminated. */
3272 convert_emchar_string_into_malloced_string (Emchar *arr, int nels,
3275 /* Damn zero-termination. */
3276 Bufbyte *str = (Bufbyte *) alloca (nels * MAX_EMCHAR_LEN + 1);
3277 Bufbyte *strorig = str;
3282 for (i = 0; i < nels; i++)
3283 str += set_charptr_emchar (str, arr[i]);
3285 len = str - strorig;
3286 str = (Bufbyte *) xmalloc (1 + len);
3287 memcpy (str, strorig, 1 + len);
3294 /************************************************************************/
3295 /* initialization */
3296 /************************************************************************/
3299 reinit_vars_of_insdel (void)
3305 inside_change_hook = 0;
3306 in_first_change = 0;
3309 for (i = 0; i <= MAX_BYTIND_GAP_SIZE_3; i++)
3310 three_to_one_table[i] = i / 3;
3315 vars_of_insdel (void)
3317 reinit_vars_of_insdel ();
3321 init_buffer_text (struct buffer *b)
3323 if (!b->base_buffer)
3325 SET_BUF_GAP_SIZE (b, 20);
3326 BUFFER_ALLOC (b->text->beg, BUF_GAP_SIZE (b) + BUF_END_SENTINEL_SIZE);
3327 if (! BUF_BEG_ADDR (b))
3330 SET_BUF_END_GAP_SIZE (b, 0);
3331 SET_BI_BUF_GPT (b, 1);
3332 SET_BOTH_BUF_Z (b, 1, 1);
3333 SET_GAP_SENTINEL (b);
3334 SET_END_SENTINEL (b);
3339 b->text->mule_bufmin = b->text->mule_bufmax = 1;
3340 b->text->mule_bytmin = b->text->mule_bytmax = 1;
3342 b->text->mule_size = 0;
3344 b->text->mule_shifter = 0;
3345 b->text->mule_three_p = 0;
3348 for (i = 0; i < 16; i++)
3350 b->text->mule_bufpos_cache[i] = 1;
3351 b->text->mule_bytind_cache[i] = 1;
3355 b->text->line_number_cache = Qnil;
3358 BUF_SAVE_MODIFF (b) = 1;
3360 JUST_SET_POINT (b, 1, 1);
3361 SET_BOTH_BUF_BEGV (b, 1, 1);
3362 SET_BOTH_BUF_ZV (b, 1, 1);
3364 b->text->changes = xnew_and_zero (struct buffer_text_change_data);
3368 JUST_SET_POINT (b, BUF_PT (b->base_buffer), BI_BUF_PT (b->base_buffer));
3369 SET_BOTH_BUF_BEGV (b, BUF_BEGV (b->base_buffer),
3370 BI_BUF_BEGV (b->base_buffer));
3371 SET_BOTH_BUF_ZV (b, BUF_ZV (b->base_buffer),
3372 BI_BUF_ZV (b->base_buffer));
3375 b->changes = xnew_and_zero (struct each_buffer_change_data);
3376 BUF_FACECHANGE (b) = 1;
3378 #ifdef REGION_CACHE_NEEDS_WORK
3379 b->newline_cache = 0;
3380 b->width_run_cache = 0;
3381 b->width_table = Qnil;
3386 uninit_buffer_text (struct buffer *b)
3388 if (!b->base_buffer)
3390 BUFFER_FREE (b->text->beg);
3391 xfree (b->text->changes);
3395 #ifdef REGION_CACHE_NEEDS_WORK
3396 if (b->newline_cache)
3398 free_region_cache (b->newline_cache);
3399 b->newline_cache = 0;
3401 if (b->width_run_cache)
3403 free_region_cache (b->width_run_cache);
3404 b->width_run_cache = 0;
3406 b->width_table = Qnil;